DER writer: Add the possibility to abandon empty SEQUENCEs
[openssl.git] / crypto / der_writer.c
1 /*
2  * Copyright 2020 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdlib.h>
11 #include <string.h>
12 #include "internal/cryptlib.h"
13 #include "internal/der.h"
14 #include "crypto/bn.h"
15
16 static int int_start_context(WPACKET *pkt, int tag)
17 {
18     if (tag < 0)
19         return 1;
20     if (!ossl_assert(tag <= 30))
21         return 0;
22     return WPACKET_start_sub_packet(pkt);
23 }
24
25 static int int_end_context(WPACKET *pkt, int tag)
26 {
27     /*
28      * If someone set the flag WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH on this
29      * sub-packet and this sub-packet has nothing written to it, the DER length
30      * will not be written, and the total written size will be unchanged before
31      * and after WPACKET_close().  We use size1 and size2 to determine if
32      * anything was written, and only write our tag if it has.
33      *
34      */
35     size_t size1, size2;
36
37     if (tag < 0)
38         return 1;
39     if (!ossl_assert(tag <= 30))
40         return 0;
41     return WPACKET_get_total_written(pkt, &size1)
42         && WPACKET_close(pkt)
43         && WPACKET_get_total_written(pkt, &size2)
44         && (size1 == size2 || WPACKET_put_bytes_u8(pkt, DER_C_CONTEXT | tag));
45 }
46
47 int DER_w_precompiled(WPACKET *pkt, int tag,
48                       const unsigned char *precompiled, size_t precompiled_n)
49 {
50     return int_start_context(pkt, tag)
51         && WPACKET_memcpy(pkt, precompiled, precompiled_n)
52         && int_end_context(pkt, tag);
53 }
54
55 int DER_w_boolean(WPACKET *pkt, int tag, int b)
56 {
57     return int_start_context(pkt, tag)
58         && WPACKET_start_sub_packet(pkt)
59         && (!b || WPACKET_put_bytes_u8(pkt, 0xFF))
60         && !WPACKET_close(pkt)
61         && !WPACKET_put_bytes_u8(pkt, DER_P_BOOLEAN)
62         && int_end_context(pkt, tag);
63 }
64
65 static int int_der_w_integer(WPACKET *pkt, int tag,
66                              int (*put_bytes)(WPACKET *pkt, const void *v,
67                                               unsigned int *top_byte),
68                              const void *v)
69 {
70     unsigned int top_byte = 0;
71
72     return int_start_context(pkt, tag)
73         && WPACKET_start_sub_packet(pkt)
74         && put_bytes(pkt, v, &top_byte)
75         && ((top_byte & 0x80) == 0 || WPACKET_put_bytes_u8(pkt, 0))
76         && WPACKET_close(pkt)
77         && WPACKET_put_bytes_u8(pkt, DER_P_INTEGER)
78         && int_end_context(pkt, tag);
79 }
80
81 static int int_put_bytes_ulong(WPACKET *pkt, const void *v,
82                                unsigned int *top_byte)
83 {
84     const unsigned long *value = v;
85     unsigned long tmp = *value;
86     size_t n = 0;
87
88     while (tmp != 0) {
89         n++;
90         *top_byte = (tmp & 0xFF);
91         tmp >>= 8;
92     }
93     if (n == 0)
94         n = 1;
95
96     return WPACKET_put_bytes__(pkt, *value, n);
97 }
98
99 /* For integers, we only support unsigned values for now */
100 int DER_w_ulong(WPACKET *pkt, int tag, unsigned long v)
101 {
102     return int_der_w_integer(pkt, tag, int_put_bytes_ulong, &v);
103 }
104
105 static int int_put_bytes_bn(WPACKET *pkt, const void *v,
106                             unsigned int *top_byte)
107 {
108     unsigned char *p = NULL;
109     size_t n = BN_num_bytes(v);
110
111     /* The BIGNUM limbs are in LE order */
112     *top_byte =
113         ((bn_get_words(v) [(n - 1) / BN_BYTES]) >> (8 * ((n - 1) % BN_BYTES)))
114         & 0xFF;
115
116     if (!WPACKET_allocate_bytes(pkt, n, &p))
117         return 0;
118     if (p != NULL)
119         BN_bn2bin(v, p);
120     return 1;
121 }
122
123 int DER_w_bn(WPACKET *pkt, int tag, const BIGNUM *v)
124 {
125     if (v == NULL || BN_is_negative(v))
126         return 0;
127     if (BN_is_zero(v))
128         return DER_w_ulong(pkt, tag, 0);
129
130     return int_der_w_integer(pkt, tag, int_put_bytes_bn, v);
131 }
132
133 int DER_w_null(WPACKET *pkt, int tag)
134 {
135     return int_start_context(pkt, tag)
136         && WPACKET_start_sub_packet(pkt)
137         && WPACKET_close(pkt)
138         && WPACKET_put_bytes_u8(pkt, DER_P_NULL)
139         && int_end_context(pkt, tag);
140 }
141
142 /* Constructed things need a start and an end */
143 int DER_w_begin_sequence(WPACKET *pkt, int tag)
144 {
145     return int_start_context(pkt, tag)
146         && WPACKET_start_sub_packet(pkt);
147 }
148
149 int DER_w_end_sequence(WPACKET *pkt, int tag)
150 {
151     /*
152      * If someone set the flag WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH on this
153      * sub-packet and this sub-packet has nothing written to it, the DER length
154      * will not be written, and the total written size will be unchanged before
155      * and after WPACKET_close().  We use size1 and size2 to determine if
156      * anything was written, and only write our tag if it has.
157      *
158      * Because we know that int_end_context() needs to do the same check,
159      * we reproduce this flag if the written length was unchanged, or we will
160      * have an erroneous context tag.
161      */
162     size_t size1, size2;
163
164     return WPACKET_get_total_written(pkt, &size1)
165         && WPACKET_close(pkt)
166         && WPACKET_get_total_written(pkt, &size2)
167         && (size1 == size2
168             ? WPACKET_set_flags(pkt, WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH)
169             : WPACKET_put_bytes_u8(pkt, DER_F_CONSTRUCTED | DER_P_SEQUENCE))
170         && int_end_context(pkt, tag);
171 }