CoCalc -- x509_decoder.c

GitHub Repository: freebsd/freebsd-src
Path: blob/main/contrib/bearssl/src/x509/x509_decoder.c
³⁹⁴⁸⁸ views
1
/* Automatically generated code; do not modify directly. */
2

3
#include <stddef.h>
4
#include <stdint.h>
5

6
typedef struct {
7
	uint32_t *dp;
8
	uint32_t *rp;
9
	const unsigned char *ip;
10
} t0_context;
11

12
static uint32_t
13
t0_parse7E_unsigned(const unsigned char **p)
14
{
15
	uint32_t x;
16

17
	x = 0;
18
	for (;;) {
19
		unsigned y;
20

21
		y = *(*p) ++;
22
		x = (x << 7) | (uint32_t)(y & 0x7F);
23
		if (y < 0x80) {
24
			return x;
25
		}
26
	}
27
}
28

29
static int32_t
30
t0_parse7E_signed(const unsigned char **p)
31
{
32
	int neg;
33
	uint32_t x;
34

35
	neg = ((**p) >> 6) & 1;
36
	x = (uint32_t)-neg;
37
	for (;;) {
38
		unsigned y;
39

40
		y = *(*p) ++;
41
		x = (x << 7) | (uint32_t)(y & 0x7F);
42
		if (y < 0x80) {
43
			if (neg) {
44
				return -(int32_t)~x - 1;
45
			} else {
46
				return (int32_t)x;
47
			}
48
		}
49
	}
50
}
51

52
#define T0_VBYTE(x, n)   (unsigned char)((((uint32_t)(x) >> (n)) & 0x7F) | 0x80)
53
#define T0_FBYTE(x, n)   (unsigned char)(((uint32_t)(x) >> (n)) & 0x7F)
54
#define T0_SBYTE(x)      (unsigned char)((((uint32_t)(x) >> 28) + 0xF8) ^ 0xF8)
55
#define T0_INT1(x)       T0_FBYTE(x, 0)
56
#define T0_INT2(x)       T0_VBYTE(x, 7), T0_FBYTE(x, 0)
57
#define T0_INT3(x)       T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
58
#define T0_INT4(x)       T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
59
#define T0_INT5(x)       T0_SBYTE(x), T0_VBYTE(x, 21), T0_VBYTE(x, 14), T0_VBYTE(x, 7), T0_FBYTE(x, 0)
60

61
/* static const unsigned char t0_datablock[]; */
62

63

64
void br_x509_decoder_init_main(void *t0ctx);
65

66
void br_x509_decoder_run(void *t0ctx);
67

68

69

70
#include "inner.h"
71

72

73

74

75

76
#include "inner.h"
77

78
#define CTX   ((br_x509_decoder_context *)(void *)((unsigned char *)t0ctx - offsetof(br_x509_decoder_context, cpu)))
79
#define CONTEXT_NAME   br_x509_decoder_context
80

81
/* see bearssl_x509.h */
82
void
83
br_x509_decoder_init(br_x509_decoder_context *ctx,
84
	void (*append_dn)(void *ctx, const void *buf, size_t len),
85
	void *append_dn_ctx)
86
{
87
	memset(ctx, 0, sizeof *ctx);
88
	/* obsolete
89
	ctx->err = 0;
90
	ctx->hbuf = NULL;
91
	ctx->hlen = 0;
92
	*/
93
	ctx->append_dn = append_dn;
94
	ctx->append_dn_ctx = append_dn_ctx;
95
	ctx->cpu.dp = &ctx->dp_stack[0];
96
	ctx->cpu.rp = &ctx->rp_stack[0];
97
	br_x509_decoder_init_main(&ctx->cpu);
98
	br_x509_decoder_run(&ctx->cpu);
99
}
100

101
/* see bearssl_x509.h */
102
void
103
br_x509_decoder_push(br_x509_decoder_context *ctx,
104
	const void *data, size_t len)
105
{
106
	ctx->hbuf = data;
107
	ctx->hlen = len;
108
	br_x509_decoder_run(&ctx->cpu);
109
}
110

111

112

113
static const unsigned char t0_datablock[] = {
114
	0x00, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x09,
115
	0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x05, 0x09, 0x2A, 0x86,
116
	0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x0E, 0x09, 0x2A, 0x86, 0x48, 0x86,
117
	0xF7, 0x0D, 0x01, 0x01, 0x0B, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D,
118
	0x01, 0x01, 0x0C, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01,
119
	0x0D, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01, 0x08, 0x2A, 0x86,
120
	0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07, 0x05, 0x2B, 0x81, 0x04, 0x00, 0x22,
121
	0x05, 0x2B, 0x81, 0x04, 0x00, 0x23, 0x07, 0x2A, 0x86, 0x48, 0xCE, 0x3D,
122
	0x04, 0x01, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x01, 0x08,
123
	0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02, 0x08, 0x2A, 0x86, 0x48,
124
	0xCE, 0x3D, 0x04, 0x03, 0x03, 0x08, 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04,
125
	0x03, 0x04, 0x00, 0x1F, 0x03, 0xFC, 0x07, 0x7F, 0x0B, 0x5E, 0x0F, 0x1F,
126
	0x12, 0xFE, 0x16, 0xBF, 0x1A, 0x9F, 0x1E, 0x7E, 0x22, 0x3F, 0x26, 0x1E,
127
	0x29, 0xDF, 0x00, 0x1F, 0x03, 0xFD, 0x07, 0x9F, 0x0B, 0x7E, 0x0F, 0x3F,
128
	0x13, 0x1E, 0x16, 0xDF, 0x1A, 0xBF, 0x1E, 0x9E, 0x22, 0x5F, 0x26, 0x3E,
129
	0x29, 0xFF, 0x03, 0x55, 0x1D, 0x13
130
};
131

132
static const unsigned char t0_codeblock[] = {
133
	0x00, 0x01, 0x00, 0x10, 0x00, 0x00, 0x01, 0x00, 0x11, 0x00, 0x00, 0x01,
134
	0x01, 0x09, 0x00, 0x00, 0x01, 0x01, 0x0A, 0x00, 0x00, 0x1A, 0x1A, 0x00,
135
	0x00, 0x01, T0_INT1(BR_ERR_X509_BAD_BOOLEAN), 0x00, 0x00, 0x01,
136
	T0_INT1(BR_ERR_X509_BAD_TAG_CLASS), 0x00, 0x00, 0x01,
137
	T0_INT1(BR_ERR_X509_BAD_TAG_VALUE), 0x00, 0x00, 0x01,
138
	T0_INT1(BR_ERR_X509_BAD_TIME), 0x00, 0x00, 0x01,
139
	T0_INT1(BR_ERR_X509_EXTRA_ELEMENT), 0x00, 0x00, 0x01,
140
	T0_INT1(BR_ERR_X509_INDEFINITE_LENGTH), 0x00, 0x00, 0x01,
141
	T0_INT1(BR_ERR_X509_INNER_TRUNC), 0x00, 0x00, 0x01,
142
	T0_INT1(BR_ERR_X509_LIMIT_EXCEEDED), 0x00, 0x00, 0x01,
143
	T0_INT1(BR_ERR_X509_NOT_CONSTRUCTED), 0x00, 0x00, 0x01,
144
	T0_INT1(BR_ERR_X509_NOT_PRIMITIVE), 0x00, 0x00, 0x01,
145
	T0_INT1(BR_ERR_X509_OVERFLOW), 0x00, 0x00, 0x01,
146
	T0_INT1(BR_ERR_X509_PARTIAL_BYTE), 0x00, 0x00, 0x01,
147
	T0_INT1(BR_ERR_X509_UNEXPECTED), 0x00, 0x00, 0x01,
148
	T0_INT1(BR_ERR_X509_UNSUPPORTED), 0x00, 0x00, 0x01,
149
	T0_INT1(BR_KEYTYPE_EC), 0x00, 0x00, 0x01, T0_INT1(BR_KEYTYPE_RSA),
150
	0x00, 0x00, 0x01, T0_INT2(offsetof(CONTEXT_NAME, copy_dn)), 0x00, 0x00,
151
	0x01, T0_INT2(offsetof(CONTEXT_NAME, decoded)), 0x00, 0x00, 0x01,
152
	T0_INT2(offsetof(CONTEXT_NAME, isCA)), 0x00, 0x00, 0x01,
153
	T0_INT2(offsetof(br_x509_decoder_context, pkey_data)), 0x01,
154
	T0_INT2(BR_X509_BUFSIZE_KEY), 0x00, 0x00, 0x01,
155
	T0_INT2(offsetof(CONTEXT_NAME, notafter_days)), 0x00, 0x00, 0x01,
156
	T0_INT2(offsetof(CONTEXT_NAME, notafter_seconds)), 0x00, 0x00, 0x01,
157
	T0_INT2(offsetof(CONTEXT_NAME, notbefore_days)), 0x00, 0x00, 0x01,
158
	T0_INT2(offsetof(CONTEXT_NAME, notbefore_seconds)), 0x00, 0x00, 0x01,
159
	T0_INT2(offsetof(CONTEXT_NAME, pad)), 0x00, 0x00, 0x01,
160
	T0_INT2(offsetof(CONTEXT_NAME, signer_hash_id)), 0x00, 0x00, 0x01,
161
	T0_INT2(offsetof(CONTEXT_NAME, signer_key_type)), 0x00, 0x00, 0x01,
162
	0x80, 0x45, 0x00, 0x00, 0x01, 0x80, 0x4E, 0x00, 0x00, 0x01, 0x80, 0x54,
163
	0x00, 0x00, 0x01, 0x81, 0x36, 0x00, 0x02, 0x03, 0x00, 0x03, 0x01, 0x1B,
164
	0x02, 0x01, 0x13, 0x26, 0x02, 0x00, 0x0F, 0x15, 0x00, 0x00, 0x05, 0x02,
165
	0x34, 0x1D, 0x00, 0x00, 0x06, 0x02, 0x35, 0x1D, 0x00, 0x00, 0x01, 0x10,
166
	0x4F, 0x00, 0x00, 0x11, 0x05, 0x02, 0x38, 0x1D, 0x4C, 0x00, 0x00, 0x11,
167
	0x05, 0x02, 0x38, 0x1D, 0x4D, 0x00, 0x00, 0x06, 0x02, 0x30, 0x1D, 0x00,
168
	0x00, 0x1B, 0x19, 0x01, 0x08, 0x0E, 0x26, 0x29, 0x19, 0x09, 0x00, 0x00,
169
	0x01, 0x30, 0x0A, 0x1B, 0x01, 0x00, 0x01, 0x09, 0x4B, 0x05, 0x02, 0x2F,
170
	0x1D, 0x00, 0x00, 0x20, 0x20, 0x00, 0x00, 0x01, 0x80, 0x5A, 0x00, 0x00,
171
	0x01, 0x80, 0x62, 0x00, 0x00, 0x01, 0x80, 0x6B, 0x00, 0x00, 0x01, 0x80,
172
	0x74, 0x00, 0x00, 0x01, 0x80, 0x7D, 0x00, 0x00, 0x01, 0x3D, 0x00, 0x00,
173
	0x20, 0x11, 0x06, 0x04, 0x2B, 0x6B, 0x7A, 0x71, 0x00, 0x04, 0x01, 0x00,
174
	0x3D, 0x25, 0x01, 0x00, 0x3C, 0x25, 0x01, 0x87, 0xFF, 0xFF, 0x7F, 0x6D,
175
	0x6D, 0x70, 0x1B, 0x01, 0x20, 0x11, 0x06, 0x11, 0x1A, 0x4C, 0x6B, 0x70,
176
	0x01, 0x02, 0x50, 0x6E, 0x01, 0x02, 0x12, 0x06, 0x02, 0x39, 0x1D, 0x51,
177
	0x70, 0x01, 0x02, 0x50, 0x6C, 0x6D, 0x7A, 0x6D, 0x7A, 0x6D, 0x65, 0x43,
178
	0x24, 0x42, 0x24, 0x65, 0x41, 0x24, 0x40, 0x24, 0x51, 0x01, 0x01, 0x3C,
179
	0x25, 0x6D, 0x7A, 0x01, 0x00, 0x3C, 0x25, 0x6D, 0x6D, 0x60, 0x05, 0x02,
180
	0x39, 0x1D, 0x74, 0x1C, 0x06, 0x1C, 0x7A, 0x61, 0x6D, 0x3F, 0x68, 0x03,
181
	0x00, 0x3F, 0x26, 0x02, 0x00, 0x09, 0x26, 0x02, 0x00, 0x0A, 0x68, 0x03,
182
	0x01, 0x51, 0x51, 0x02, 0x00, 0x02, 0x01, 0x18, 0x04, 0x1E, 0x5A, 0x1C,
183
	0x06, 0x18, 0x64, 0x03, 0x02, 0x51, 0x61, 0x1B, 0x03, 0x03, 0x1B, 0x3F,
184
	0x23, 0x0D, 0x06, 0x02, 0x33, 0x1D, 0x62, 0x02, 0x02, 0x02, 0x03, 0x17,
185
	0x04, 0x02, 0x39, 0x1D, 0x51, 0x01, 0x00, 0x3E, 0x25, 0x71, 0x01, 0x21,
186
	0x5B, 0x01, 0x22, 0x5B, 0x1B, 0x01, 0x23, 0x11, 0x06, 0x28, 0x1A, 0x4C,
187
	0x6B, 0x6D, 0x1B, 0x06, 0x1D, 0x6D, 0x60, 0x1A, 0x70, 0x1B, 0x01, 0x01,
188
	0x11, 0x06, 0x03, 0x63, 0x1A, 0x70, 0x01, 0x04, 0x50, 0x6B, 0x4A, 0x1C,
189
	0x06, 0x03, 0x5F, 0x04, 0x01, 0x7B, 0x51, 0x51, 0x04, 0x60, 0x51, 0x51,
190
	0x04, 0x08, 0x01, 0x7F, 0x11, 0x05, 0x02, 0x38, 0x1D, 0x1A, 0x51, 0x6D,
191
	0x60, 0x06, 0x80, 0x63, 0x75, 0x1C, 0x06, 0x06, 0x01, 0x02, 0x3B, 0x04,
192
	0x80, 0x57, 0x76, 0x1C, 0x06, 0x06, 0x01, 0x03, 0x3B, 0x04, 0x80, 0x4D,
193
	0x77, 0x1C, 0x06, 0x06, 0x01, 0x04, 0x3B, 0x04, 0x80, 0x43, 0x78, 0x1C,
194
	0x06, 0x05, 0x01, 0x05, 0x3B, 0x04, 0x3A, 0x79, 0x1C, 0x06, 0x05, 0x01,
195
	0x06, 0x3B, 0x04, 0x31, 0x55, 0x1C, 0x06, 0x05, 0x01, 0x02, 0x3A, 0x04,
196
	0x28, 0x56, 0x1C, 0x06, 0x05, 0x01, 0x03, 0x3A, 0x04, 0x1F, 0x57, 0x1C,
197
	0x06, 0x05, 0x01, 0x04, 0x3A, 0x04, 0x16, 0x58, 0x1C, 0x06, 0x05, 0x01,
198
	0x05, 0x3A, 0x04, 0x0D, 0x59, 0x1C, 0x06, 0x05, 0x01, 0x06, 0x3A, 0x04,
199
	0x04, 0x01, 0x00, 0x01, 0x00, 0x04, 0x04, 0x01, 0x00, 0x01, 0x00, 0x46,
200
	0x25, 0x45, 0x25, 0x7A, 0x61, 0x7A, 0x51, 0x1A, 0x01, 0x01, 0x3D, 0x25,
201
	0x73, 0x30, 0x1D, 0x00, 0x00, 0x01, 0x81, 0x06, 0x00, 0x01, 0x54, 0x0D,
202
	0x06, 0x02, 0x32, 0x1D, 0x1B, 0x03, 0x00, 0x0A, 0x02, 0x00, 0x00, 0x00,
203
	0x6D, 0x71, 0x1B, 0x01, 0x01, 0x11, 0x06, 0x08, 0x63, 0x01, 0x01, 0x15,
204
	0x3E, 0x25, 0x04, 0x01, 0x2B, 0x7A, 0x00, 0x00, 0x70, 0x01, 0x06, 0x50,
205
	0x6F, 0x00, 0x00, 0x70, 0x01, 0x03, 0x50, 0x6B, 0x72, 0x06, 0x02, 0x37,
206
	0x1D, 0x00, 0x00, 0x26, 0x1B, 0x06, 0x07, 0x21, 0x1B, 0x06, 0x01, 0x16,
207
	0x04, 0x76, 0x2B, 0x00, 0x00, 0x01, 0x01, 0x50, 0x6A, 0x01, 0x01, 0x10,
208
	0x06, 0x02, 0x2C, 0x1D, 0x72, 0x27, 0x00, 0x00, 0x60, 0x05, 0x02, 0x39,
209
	0x1D, 0x47, 0x1C, 0x06, 0x04, 0x01, 0x17, 0x04, 0x12, 0x48, 0x1C, 0x06,
210
	0x04, 0x01, 0x18, 0x04, 0x0A, 0x49, 0x1C, 0x06, 0x04, 0x01, 0x19, 0x04,
211
	0x02, 0x39, 0x1D, 0x00, 0x04, 0x70, 0x1B, 0x01, 0x17, 0x01, 0x18, 0x4B,
212
	0x05, 0x02, 0x2F, 0x1D, 0x01, 0x18, 0x11, 0x03, 0x00, 0x4D, 0x6B, 0x66,
213
	0x02, 0x00, 0x06, 0x0C, 0x01, 0x80, 0x64, 0x08, 0x03, 0x01, 0x66, 0x02,
214
	0x01, 0x09, 0x04, 0x0E, 0x1B, 0x01, 0x32, 0x0D, 0x06, 0x04, 0x01, 0x80,
215
	0x64, 0x09, 0x01, 0x8E, 0x6C, 0x09, 0x03, 0x01, 0x02, 0x01, 0x01, 0x82,
216
	0x6D, 0x08, 0x02, 0x01, 0x01, 0x03, 0x09, 0x01, 0x04, 0x0C, 0x09, 0x02,
217
	0x01, 0x01, 0x80, 0x63, 0x09, 0x01, 0x80, 0x64, 0x0C, 0x0A, 0x02, 0x01,
218
	0x01, 0x83, 0x0F, 0x09, 0x01, 0x83, 0x10, 0x0C, 0x09, 0x03, 0x03, 0x01,
219
	0x01, 0x01, 0x0C, 0x67, 0x2A, 0x01, 0x01, 0x0E, 0x02, 0x01, 0x01, 0x04,
220
	0x07, 0x28, 0x02, 0x01, 0x01, 0x80, 0x64, 0x07, 0x27, 0x02, 0x01, 0x01,
221
	0x83, 0x10, 0x07, 0x28, 0x1F, 0x15, 0x06, 0x03, 0x01, 0x18, 0x09, 0x5D,
222
	0x09, 0x52, 0x1B, 0x01, 0x05, 0x14, 0x02, 0x03, 0x09, 0x03, 0x03, 0x01,
223
	0x1F, 0x15, 0x01, 0x01, 0x26, 0x67, 0x02, 0x03, 0x09, 0x2A, 0x03, 0x03,
224
	0x01, 0x00, 0x01, 0x17, 0x67, 0x01, 0x9C, 0x10, 0x08, 0x03, 0x02, 0x01,
225
	0x00, 0x01, 0x3B, 0x67, 0x01, 0x3C, 0x08, 0x02, 0x02, 0x09, 0x03, 0x02,
226
	0x01, 0x00, 0x01, 0x3C, 0x67, 0x02, 0x02, 0x09, 0x03, 0x02, 0x72, 0x1B,
227
	0x01, 0x2E, 0x11, 0x06, 0x0D, 0x1A, 0x72, 0x1B, 0x01, 0x30, 0x01, 0x39,
228
	0x4B, 0x06, 0x03, 0x1A, 0x04, 0x74, 0x01, 0x80, 0x5A, 0x10, 0x06, 0x02,
229
	0x2F, 0x1D, 0x51, 0x02, 0x03, 0x02, 0x02, 0x00, 0x01, 0x72, 0x53, 0x01,
230
	0x0A, 0x08, 0x03, 0x00, 0x72, 0x53, 0x02, 0x00, 0x09, 0x00, 0x02, 0x03,
231
	0x00, 0x03, 0x01, 0x66, 0x1B, 0x02, 0x01, 0x02, 0x00, 0x4B, 0x05, 0x02,
232
	0x2F, 0x1D, 0x00, 0x00, 0x23, 0x70, 0x01, 0x02, 0x50, 0x0B, 0x69, 0x00,
233
	0x03, 0x1B, 0x03, 0x00, 0x03, 0x01, 0x03, 0x02, 0x6B, 0x72, 0x1B, 0x01,
234
	0x81, 0x00, 0x13, 0x06, 0x02, 0x36, 0x1D, 0x1B, 0x01, 0x00, 0x11, 0x06,
235
	0x0B, 0x1A, 0x1B, 0x05, 0x04, 0x1A, 0x01, 0x00, 0x00, 0x72, 0x04, 0x6F,
236
	0x02, 0x01, 0x1B, 0x05, 0x02, 0x33, 0x1D, 0x2A, 0x03, 0x01, 0x02, 0x02,
237
	0x25, 0x02, 0x02, 0x29, 0x03, 0x02, 0x1B, 0x06, 0x03, 0x72, 0x04, 0x68,
238
	0x1A, 0x02, 0x00, 0x02, 0x01, 0x0A, 0x00, 0x01, 0x72, 0x1B, 0x01, 0x81,
239
	0x00, 0x0D, 0x06, 0x01, 0x00, 0x01, 0x81, 0x00, 0x0A, 0x1B, 0x05, 0x02,
240
	0x31, 0x1D, 0x03, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01, 0x00, 0x12, 0x06,
241
	0x19, 0x02, 0x00, 0x2A, 0x03, 0x00, 0x1B, 0x01, 0x83, 0xFF, 0xFF, 0x7F,
242
	0x12, 0x06, 0x02, 0x32, 0x1D, 0x01, 0x08, 0x0E, 0x26, 0x72, 0x23, 0x09,
243
	0x04, 0x60, 0x00, 0x00, 0x6A, 0x5E, 0x00, 0x00, 0x6B, 0x7A, 0x00, 0x00,
244
	0x70, 0x4E, 0x6B, 0x00, 0x01, 0x6B, 0x1B, 0x05, 0x02, 0x36, 0x1D, 0x72,
245
	0x1B, 0x01, 0x81, 0x00, 0x13, 0x06, 0x02, 0x36, 0x1D, 0x03, 0x00, 0x1B,
246
	0x06, 0x16, 0x72, 0x02, 0x00, 0x1B, 0x01, 0x87, 0xFF, 0xFF, 0x7F, 0x13,
247
	0x06, 0x02, 0x36, 0x1D, 0x01, 0x08, 0x0E, 0x09, 0x03, 0x00, 0x04, 0x67,
248
	0x1A, 0x02, 0x00, 0x00, 0x00, 0x6B, 0x1B, 0x01, 0x81, 0x7F, 0x12, 0x06,
249
	0x08, 0x7A, 0x01, 0x00, 0x44, 0x25, 0x01, 0x00, 0x00, 0x1B, 0x44, 0x25,
250
	0x44, 0x29, 0x62, 0x01, 0x7F, 0x00, 0x01, 0x72, 0x03, 0x00, 0x02, 0x00,
251
	0x01, 0x05, 0x14, 0x01, 0x01, 0x15, 0x1E, 0x02, 0x00, 0x01, 0x06, 0x14,
252
	0x1B, 0x01, 0x01, 0x15, 0x06, 0x02, 0x2D, 0x1D, 0x01, 0x04, 0x0E, 0x02,
253
	0x00, 0x01, 0x1F, 0x15, 0x1B, 0x01, 0x1F, 0x11, 0x06, 0x02, 0x2E, 0x1D,
254
	0x09, 0x00, 0x00, 0x1B, 0x05, 0x05, 0x01, 0x00, 0x01, 0x7F, 0x00, 0x70,
255
	0x00, 0x00, 0x1B, 0x05, 0x02, 0x32, 0x1D, 0x2A, 0x73, 0x00, 0x00, 0x22,
256
	0x1B, 0x01, 0x00, 0x13, 0x06, 0x01, 0x00, 0x1A, 0x16, 0x04, 0x74, 0x00,
257
	0x01, 0x01, 0x00, 0x00, 0x01, 0x0B, 0x00, 0x00, 0x01, 0x15, 0x00, 0x00,
258
	0x01, 0x1F, 0x00, 0x00, 0x01, 0x29, 0x00, 0x00, 0x01, 0x33, 0x00, 0x00,
259
	0x7B, 0x1A, 0x00, 0x00, 0x1B, 0x06, 0x07, 0x7C, 0x1B, 0x06, 0x01, 0x16,
260
	0x04, 0x76, 0x00, 0x00, 0x01, 0x00, 0x20, 0x21, 0x0B, 0x2B, 0x00
261
};
262

263
static const uint16_t t0_caddr[] = {
264
	0,
265
	5,
266
	10,
267
	15,
268
	20,
269
	24,
270
	28,
271
	32,
272
	36,
273
	40,
274
	44,
275
	48,
276
	52,
277
	56,
278
	60,
279
	64,
280
	68,
281
	72,
282
	76,
283
	80,
284
	84,
285
	88,
286
	93,
287
	98,
288
	103,
289
	111,
290
	116,
291
	121,
292
	126,
293
	131,
294
	136,
295
	141,
296
	146,
297
	151,
298
	156,
299
	161,
300
	166,
301
	181,
302
	187,
303
	193,
304
	198,
305
	206,
306
	214,
307
	220,
308
	231,
309
	246,
310
	250,
311
	255,
312
	260,
313
	265,
314
	270,
315
	275,
316
	279,
317
	289,
318
	620,
319
	625,
320
	639,
321
	659,
322
	666,
323
	678,
324
	692,
325
	707,
326
	740,
327
	960,
328
	974,
329
	991,
330
	1000,
331
	1067,
332
	1123,
333
	1127,
334
	1131,
335
	1136,
336
	1184,
337
	1210,
338
	1254,
339
	1265,
340
	1274,
341
	1287,
342
	1291,
343
	1295,
344
	1299,
345
	1303,
346
	1307,
347
	1311,
348
	1315,
349
	1327
350
};
351

352
#define T0_INTERPRETED   39
353

354
#define T0_ENTER(ip, rp, slot)   do { \
355
		const unsigned char *t0_newip; \
356
		uint32_t t0_lnum; \
357
		t0_newip = &t0_codeblock[t0_caddr[(slot) - T0_INTERPRETED]]; \
358
		t0_lnum = t0_parse7E_unsigned(&t0_newip); \
359
		(rp) += t0_lnum; \
360
		*((rp) ++) = (uint32_t)((ip) - &t0_codeblock[0]) + (t0_lnum << 16); \
361
		(ip) = t0_newip; \
362
	} while (0)
363

364
#define T0_DEFENTRY(name, slot) \
365
void \
366
name(void *ctx) \
367
{ \
368
	t0_context *t0ctx = ctx; \
369
	t0ctx->ip = &t0_codeblock[0]; \
370
	T0_ENTER(t0ctx->ip, t0ctx->rp, slot); \
371
}
372

373
T0_DEFENTRY(br_x509_decoder_init_main, 92)
374

375
#define T0_NEXT(t0ipp)   (*(*(t0ipp)) ++)
376

377
void
378
br_x509_decoder_run(void *t0ctx)
379
{
380
	uint32_t *dp, *rp;
381
	const unsigned char *ip;
382

383
#define T0_LOCAL(x)    (*(rp - 2 - (x)))
384
#define T0_POP()       (*-- dp)
385
#define T0_POPi()      (*(int32_t *)(-- dp))
386
#define T0_PEEK(x)     (*(dp - 1 - (x)))
387
#define T0_PEEKi(x)    (*(int32_t *)(dp - 1 - (x)))
388
#define T0_PUSH(v)     do { *dp = (v); dp ++; } while (0)
389
#define T0_PUSHi(v)    do { *(int32_t *)dp = (v); dp ++; } while (0)
390
#define T0_RPOP()      (*-- rp)
391
#define T0_RPOPi()     (*(int32_t *)(-- rp))
392
#define T0_RPUSH(v)    do { *rp = (v); rp ++; } while (0)
393
#define T0_RPUSHi(v)   do { *(int32_t *)rp = (v); rp ++; } while (0)
394
#define T0_ROLL(x)     do { \
395
	size_t t0len = (size_t)(x); \
396
	uint32_t t0tmp = *(dp - 1 - t0len); \
397
	memmove(dp - t0len - 1, dp - t0len, t0len * sizeof *dp); \
398
	*(dp - 1) = t0tmp; \
399
} while (0)
400
#define T0_SWAP()      do { \
401
	uint32_t t0tmp = *(dp - 2); \
402
	*(dp - 2) = *(dp - 1); \
403
	*(dp - 1) = t0tmp; \
404
} while (0)
405
#define T0_ROT()       do { \
406
	uint32_t t0tmp = *(dp - 3); \
407
	*(dp - 3) = *(dp - 2); \
408
	*(dp - 2) = *(dp - 1); \
409
	*(dp - 1) = t0tmp; \
410
} while (0)
411
#define T0_NROT()       do { \
412
	uint32_t t0tmp = *(dp - 1); \
413
	*(dp - 1) = *(dp - 2); \
414
	*(dp - 2) = *(dp - 3); \
415
	*(dp - 3) = t0tmp; \
416
} while (0)
417
#define T0_PICK(x)      do { \
418
	uint32_t t0depth = (x); \
419
	T0_PUSH(T0_PEEK(t0depth)); \
420
} while (0)
421
#define T0_CO()         do { \
422
	goto t0_exit; \
423
} while (0)
424
#define T0_RET()        goto t0_next
425

426
	dp = ((t0_context *)t0ctx)->dp;
427
	rp = ((t0_context *)t0ctx)->rp;
428
	ip = ((t0_context *)t0ctx)->ip;
429
	goto t0_next;
430
	for (;;) {
431
		uint32_t t0x;
432

433
	t0_next:
434
		t0x = T0_NEXT(&ip);
435
		if (t0x < T0_INTERPRETED) {
436
			switch (t0x) {
437
				int32_t t0off;
438

439
			case 0: /* ret */
440
				t0x = T0_RPOP();
441
				rp -= (t0x >> 16);
442
				t0x &= 0xFFFF;
443
				if (t0x == 0) {
444
					ip = NULL;
445
					goto t0_exit;
446
				}
447
				ip = &t0_codeblock[t0x];
448
				break;
449
			case 1: /* literal constant */
450
				T0_PUSHi(t0_parse7E_signed(&ip));
451
				break;
452
			case 2: /* read local */
453
				T0_PUSH(T0_LOCAL(t0_parse7E_unsigned(&ip)));
454
				break;
455
			case 3: /* write local */
456
				T0_LOCAL(t0_parse7E_unsigned(&ip)) = T0_POP();
457
				break;
458
			case 4: /* jump */
459
				t0off = t0_parse7E_signed(&ip);
460
				ip += t0off;
461
				break;
462
			case 5: /* jump if */
463
				t0off = t0_parse7E_signed(&ip);
464
				if (T0_POP()) {
465
					ip += t0off;
466
				}
467
				break;
468
			case 6: /* jump if not */
469
				t0off = t0_parse7E_signed(&ip);
470
				if (!T0_POP()) {
471
					ip += t0off;
472
				}
473
				break;
474
			case 7: {
475
				/* %25 */
476

477
	int32_t b = T0_POPi();
478
	int32_t a = T0_POPi();
479
	T0_PUSHi(a % b);
480

481
				}
482
				break;
483
			case 8: {
484
				/* * */
485

486
	uint32_t b = T0_POP();
487
	uint32_t a = T0_POP();
488
	T0_PUSH(a * b);
489

490
				}
491
				break;
492
			case 9: {
493
				/* + */
494

495
	uint32_t b = T0_POP();
496
	uint32_t a = T0_POP();
497
	T0_PUSH(a + b);
498

499
				}
500
				break;
501
			case 10: {
502
				/* - */
503

504
	uint32_t b = T0_POP();
505
	uint32_t a = T0_POP();
506
	T0_PUSH(a - b);
507

508
				}
509
				break;
510
			case 11: {
511
				/* -rot */
512
 T0_NROT(); 
513
				}
514
				break;
515
			case 12: {
516
				/* / */
517

518
	int32_t b = T0_POPi();
519
	int32_t a = T0_POPi();
520
	T0_PUSHi(a / b);
521

522
				}
523
				break;
524
			case 13: {
525
				/* < */
526

527
	int32_t b = T0_POPi();
528
	int32_t a = T0_POPi();
529
	T0_PUSH(-(uint32_t)(a < b));
530

531
				}
532
				break;
533
			case 14: {
534
				/* << */
535

536
	int c = (int)T0_POPi();
537
	uint32_t x = T0_POP();
538
	T0_PUSH(x << c);
539

540
				}
541
				break;
542
			case 15: {
543
				/* <= */
544

545
	int32_t b = T0_POPi();
546
	int32_t a = T0_POPi();
547
	T0_PUSH(-(uint32_t)(a <= b));
548

549
				}
550
				break;
551
			case 16: {
552
				/* <> */
553

554
	uint32_t b = T0_POP();
555
	uint32_t a = T0_POP();
556
	T0_PUSH(-(uint32_t)(a != b));
557

558
				}
559
				break;
560
			case 17: {
561
				/* = */
562

563
	uint32_t b = T0_POP();
564
	uint32_t a = T0_POP();
565
	T0_PUSH(-(uint32_t)(a == b));
566

567
				}
568
				break;
569
			case 18: {
570
				/* > */
571

572
	int32_t b = T0_POPi();
573
	int32_t a = T0_POPi();
574
	T0_PUSH(-(uint32_t)(a > b));
575

576
				}
577
				break;
578
			case 19: {
579
				/* >= */
580

581
	int32_t b = T0_POPi();
582
	int32_t a = T0_POPi();
583
	T0_PUSH(-(uint32_t)(a >= b));
584

585
				}
586
				break;
587
			case 20: {
588
				/* >> */
589

590
	int c = (int)T0_POPi();
591
	int32_t x = T0_POPi();
592
	T0_PUSHi(x >> c);
593

594
				}
595
				break;
596
			case 21: {
597
				/* and */
598

599
	uint32_t b = T0_POP();
600
	uint32_t a = T0_POP();
601
	T0_PUSH(a & b);
602

603
				}
604
				break;
605
			case 22: {
606
				/* co */
607
 T0_CO(); 
608
				}
609
				break;
610
			case 23: {
611
				/* copy-ec-pkey */
612

613
	size_t qlen = T0_POP();
614
	uint32_t curve = T0_POP();
615
	CTX->pkey.key_type = BR_KEYTYPE_EC;
616
	CTX->pkey.key.ec.curve = curve;
617
	CTX->pkey.key.ec.q = CTX->pkey_data;
618
	CTX->pkey.key.ec.qlen = qlen;
619

620
				}
621
				break;
622
			case 24: {
623
				/* copy-rsa-pkey */
624

625
	size_t elen = T0_POP();
626
	size_t nlen = T0_POP();
627
	CTX->pkey.key_type = BR_KEYTYPE_RSA;
628
	CTX->pkey.key.rsa.n = CTX->pkey_data;
629
	CTX->pkey.key.rsa.nlen = nlen;
630
	CTX->pkey.key.rsa.e = CTX->pkey_data + nlen;
631
	CTX->pkey.key.rsa.elen = elen;
632

633
				}
634
				break;
635
			case 25: {
636
				/* data-get8 */
637

638
	size_t addr = T0_POP();
639
	T0_PUSH(t0_datablock[addr]);
640

641
				}
642
				break;
643
			case 26: {
644
				/* drop */
645
 (void)T0_POP(); 
646
				}
647
				break;
648
			case 27: {
649
				/* dup */
650
 T0_PUSH(T0_PEEK(0)); 
651
				}
652
				break;
653
			case 28: {
654
				/* eqOID */
655

656
	const unsigned char *a2 = &t0_datablock[T0_POP()];
657
	const unsigned char *a1 = &CTX->pad[0];
658
	size_t len = a1[0];
659
	int x;
660
	if (len == a2[0]) {
661
		x = -(memcmp(a1 + 1, a2 + 1, len) == 0);
662
	} else {
663
		x = 0;
664
	}
665
	T0_PUSH((uint32_t)x);
666

667
				}
668
				break;
669
			case 29: {
670
				/* fail */
671

672
	CTX->err = T0_POPi();
673
	T0_CO();
674

675
				}
676
				break;
677
			case 30: {
678
				/* neg */
679

680
	uint32_t a = T0_POP();
681
	T0_PUSH(-a);
682

683
				}
684
				break;
685
			case 31: {
686
				/* or */
687

688
	uint32_t b = T0_POP();
689
	uint32_t a = T0_POP();
690
	T0_PUSH(a | b);
691

692
				}
693
				break;
694
			case 32: {
695
				/* over */
696
 T0_PUSH(T0_PEEK(1)); 
697
				}
698
				break;
699
			case 33: {
700
				/* read-blob-inner */
701

702
	uint32_t len = T0_POP();
703
	uint32_t addr = T0_POP();
704
	size_t clen = CTX->hlen;
705
	if (clen > len) {
706
		clen = (size_t)len;
707
	}
708
	if (addr != 0) {
709
		memcpy((unsigned char *)CTX + addr, CTX->hbuf, clen);
710
	}
711
	if (CTX->copy_dn && CTX->append_dn) {
712
		CTX->append_dn(CTX->append_dn_ctx, CTX->hbuf, clen);
713
	}
714
	CTX->hbuf += clen;
715
	CTX->hlen -= clen;
716
	T0_PUSH(addr + clen);
717
	T0_PUSH(len - clen);
718

719
				}
720
				break;
721
			case 34: {
722
				/* read8-low */
723

724
	if (CTX->hlen == 0) {
725
		T0_PUSHi(-1);
726
	} else {
727
		unsigned char x = *CTX->hbuf ++;
728
		if (CTX->copy_dn && CTX->append_dn) {
729
			CTX->append_dn(CTX->append_dn_ctx, &x, 1);
730
		}
731
		CTX->hlen --;
732
		T0_PUSH(x);
733
	}
734

735
				}
736
				break;
737
			case 35: {
738
				/* rot */
739
 T0_ROT(); 
740
				}
741
				break;
742
			case 36: {
743
				/* set32 */
744

745
	uint32_t addr = T0_POP();
746
	*(uint32_t *)(void *)((unsigned char *)CTX + addr) = T0_POP();
747

748
				}
749
				break;
750
			case 37: {
751
				/* set8 */
752

753
	uint32_t addr = T0_POP();
754
	*((unsigned char *)CTX + addr) = (unsigned char)T0_POP();
755

756
				}
757
				break;
758
			case 38: {
759
				/* swap */
760
 T0_SWAP(); 
761
				}
762
				break;
763
			}
764

765
		} else {
766
			T0_ENTER(ip, rp, t0x);
767
		}
768
	}
769
t0_exit:
770
	((t0_context *)t0ctx)->dp = dp;
771
	((t0_context *)t0ctx)->rp = rp;
772
	((t0_context *)t0ctx)->ip = ip;
773
}
774

775
Product

Resources

Company
