Branch data Line data Source code
1 : : /*
2 : : * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
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 : : * A copy of the License is located at
7 : : *
8 : : * http://aws.amazon.com/apache2.0
9 : : *
10 : : * or in the "license" file accompanying this file. This file is distributed
11 : : * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
12 : : * express or implied. See the License for the specific language governing
13 : : * permissions and limitations under the License.
14 : : */
15 : :
16 : : #include "error/s2n_errno.h"
17 : : #include "stuffer/s2n_stuffer.h"
18 : : #include "utils/s2n_annotations.h"
19 : : #include "utils/s2n_safety.h"
20 : :
21 : : /* Writes length bytes of input to stuffer, in network order, starting from the smallest byte of input. */
22 : : int s2n_stuffer_write_network_order(struct s2n_stuffer *stuffer, const uint64_t input, const uint8_t length)
23 : 4785966 : {
24 [ + + ]: 4785966 : if (length == 0) {
25 : 1 : return S2N_SUCCESS;
26 : 1 : }
27 [ + + ][ + - ]: 4785965 : POSIX_ENSURE_REF(stuffer);
28 [ - + ][ # # ]: 4785960 : POSIX_ENSURE(length <= sizeof(input), S2N_ERR_SAFETY);
29 [ + + ]: 4785960 : POSIX_GUARD(s2n_stuffer_skip_write(stuffer, length));
30 [ # # ][ - + ]: 4785956 : POSIX_ENSURE_REF(stuffer->blob.data);
31 : 4785956 : uint8_t *data = stuffer->blob.data + stuffer->write_cursor - length;
32 [ + + ]: 14680114 : for (int i = 0; i < length; i++) {
33 : 9894158 : S2N_INVARIANT(i <= length);
34 : 9894158 : uint8_t shift = (length - i - 1) * CHAR_BIT;
35 : 9894158 : data[i] = (input >> (shift)) & UINT8_MAX;
36 : 9894158 : }
37 [ - + ][ + - ]: 4785956 : POSIX_POSTCONDITION(s2n_stuffer_validate(stuffer));
38 : 4785956 : return S2N_SUCCESS;
39 : 4785956 : }
40 : :
41 : : int s2n_stuffer_reserve(struct s2n_stuffer *stuffer, struct s2n_stuffer_reservation *reservation, const uint8_t length)
42 : 119886 : {
43 [ + + ][ + + ]: 119886 : POSIX_PRECONDITION(s2n_stuffer_validate(stuffer));
44 [ + + ][ + - ]: 119883 : POSIX_ENSURE_REF(reservation);
45 : :
46 : 119881 : *reservation = (struct s2n_stuffer_reservation){ .stuffer = stuffer,
47 : 119881 : .write_cursor = stuffer->write_cursor,
48 : 119881 : .length = length };
49 : :
50 [ + + ]: 119881 : POSIX_GUARD(s2n_stuffer_skip_write(stuffer, reservation->length));
51 [ # # ][ - + ]: 119880 : POSIX_CHECKED_MEMSET(stuffer->blob.data + reservation->write_cursor, S2N_WIPE_PATTERN, reservation->length);
[ + - ]
52 [ - + ][ + - ]: 119880 : POSIX_POSTCONDITION(s2n_stuffer_reservation_validate(reservation));
53 : 119880 : return S2N_SUCCESS;
54 : 119880 : }
55 : :
56 : : int s2n_stuffer_read_uint8(struct s2n_stuffer *stuffer, uint8_t *u)
57 : 7649090 : {
58 [ + + ]: 7649090 : POSIX_GUARD(s2n_stuffer_read_bytes(stuffer, u, sizeof(uint8_t)));
59 : :
60 : 7632579 : return S2N_SUCCESS;
61 : 7649090 : }
62 : :
63 : : int s2n_stuffer_write_uint8(struct s2n_stuffer *stuffer, const uint8_t u)
64 : 5534833 : {
65 [ + + ]: 5534833 : POSIX_GUARD(s2n_stuffer_write_bytes(stuffer, &u, sizeof(u)));
66 : :
67 : 5534831 : return S2N_SUCCESS;
68 : 5534833 : }
69 : :
70 : : int s2n_stuffer_reserve_uint8(struct s2n_stuffer *stuffer, struct s2n_stuffer_reservation *reservation)
71 : 8 : {
72 : 8 : return s2n_stuffer_reserve(stuffer, reservation, sizeof(uint8_t));
73 : 8 : }
74 : :
75 : : int s2n_stuffer_read_uint16(struct s2n_stuffer *stuffer, uint16_t *u)
76 : 7792592 : {
77 [ # # ][ - + ]: 7792592 : POSIX_ENSURE_REF(u);
78 : 7792592 : uint8_t data[sizeof(uint16_t)];
79 : :
80 [ + + ]: 7792592 : POSIX_GUARD(s2n_stuffer_read_bytes(stuffer, data, sizeof(data)));
81 : :
82 : 7792465 : *u = data[0] << 8;
83 : 7792465 : *u |= data[1];
84 : :
85 : 7792465 : return S2N_SUCCESS;
86 : 7792592 : }
87 : :
88 : : int s2n_stuffer_write_uint16(struct s2n_stuffer *stuffer, const uint16_t u)
89 : 4360174 : {
90 : 4360174 : return s2n_stuffer_write_network_order(stuffer, u, sizeof(u));
91 : 4360174 : }
92 : :
93 : : int s2n_stuffer_reserve_uint16(struct s2n_stuffer *stuffer, struct s2n_stuffer_reservation *reservation)
94 : 114089 : {
95 : 114089 : return s2n_stuffer_reserve(stuffer, reservation, sizeof(uint16_t));
96 : 114089 : }
97 : :
98 : : int s2n_stuffer_read_uint24(struct s2n_stuffer *stuffer, uint32_t *u)
99 : 158190 : {
100 [ - + ][ # # ]: 158190 : POSIX_ENSURE_REF(u);
101 : 158190 : uint8_t data[SIZEOF_UINT24];
102 : :
103 [ - + ]: 158190 : POSIX_GUARD(s2n_stuffer_read_bytes(stuffer, data, sizeof(data)));
104 : :
105 : 158190 : *u = data[0] << 16;
106 : 158190 : *u |= data[1] << 8;
107 : 158190 : *u |= data[2];
108 : :
109 : 158190 : return S2N_SUCCESS;
110 : 158190 : }
111 : :
112 : : int s2n_stuffer_write_uint24(struct s2n_stuffer *stuffer, const uint32_t u)
113 : 103942 : {
114 [ + + ][ + - ]: 103942 : POSIX_ENSURE(u < (1 << 24), S2N_ERR_INTEGER_OVERFLOW);
115 : 103941 : return s2n_stuffer_write_network_order(stuffer, u, SIZEOF_UINT24);
116 : 103942 : }
117 : :
118 : : int s2n_stuffer_reserve_uint24(struct s2n_stuffer *stuffer, struct s2n_stuffer_reservation *reservation)
119 : 5789 : {
120 : 5789 : return s2n_stuffer_reserve(stuffer, reservation, SIZEOF_UINT24);
121 : 5789 : }
122 : :
123 : : int s2n_stuffer_read_uint32(struct s2n_stuffer *stuffer, uint32_t *u)
124 : 67734 : {
125 [ - + ][ # # ]: 67734 : POSIX_ENSURE_REF(u);
126 : 67734 : uint8_t data[sizeof(uint32_t)];
127 : :
128 [ + + ]: 67734 : POSIX_GUARD(s2n_stuffer_read_bytes(stuffer, data, sizeof(data)));
129 : :
130 : 67731 : *u = ((uint32_t) data[0]) << 24;
131 : 67731 : *u |= data[1] << 16;
132 : 67731 : *u |= data[2] << 8;
133 : 67731 : *u |= data[3];
134 : :
135 : 67731 : return S2N_SUCCESS;
136 : 67734 : }
137 : :
138 : : int s2n_stuffer_write_uint32(struct s2n_stuffer *stuffer, const uint32_t u)
139 : 3950 : {
140 : 3950 : return s2n_stuffer_write_network_order(stuffer, u, sizeof(u));
141 : 3950 : }
142 : :
143 : : int s2n_stuffer_read_uint64(struct s2n_stuffer *stuffer, uint64_t *u)
144 : 506 : {
145 [ # # ][ - + ]: 506 : POSIX_ENSURE_REF(u);
146 : 506 : uint8_t data[sizeof(uint64_t)];
147 : :
148 [ + + ]: 506 : POSIX_GUARD(s2n_stuffer_read_bytes(stuffer, data, sizeof(data)));
149 : :
150 : 505 : *u = ((uint64_t) data[0]) << 56;
151 : 505 : *u |= ((uint64_t) data[1]) << 48;
152 : 505 : *u |= ((uint64_t) data[2]) << 40;
153 : 505 : *u |= ((uint64_t) data[3]) << 32;
154 : 505 : *u |= ((uint64_t) data[4]) << 24;
155 : 505 : *u |= ((uint64_t) data[5]) << 16;
156 : 505 : *u |= ((uint64_t) data[6]) << 8;
157 : 505 : *u |= data[7];
158 : :
159 : 505 : return S2N_SUCCESS;
160 : 506 : }
161 : :
162 : : int s2n_stuffer_write_uint64(struct s2n_stuffer *stuffer, const uint64_t u)
163 : 1423 : {
164 : 1423 : return s2n_stuffer_write_network_order(stuffer, u, sizeof(u));
165 : 1423 : }
166 : :
167 : : static int length_matches_value_check(uint32_t value, uint8_t length)
168 : 119865 : {
169 : : /* Value is represented as a uint32_t, so shouldn't be assumed larger */
170 [ - + ][ # # ]: 119865 : POSIX_ENSURE(length <= sizeof(uint32_t), S2N_ERR_SIZE_MISMATCH);
171 : :
172 [ + - ]: 119865 : if (length < sizeof(uint32_t)) {
173 : : /* Value should be less than the maximum for its length */
174 : 119865 : const uint32_t size_max = 1 << (length * 8);
175 [ + + ][ + - ]: 119865 : POSIX_ENSURE(value < size_max, S2N_ERR_SIZE_MISMATCH);
176 : 119865 : }
177 : :
178 : 119863 : return S2N_SUCCESS;
179 : 119865 : }
180 : :
181 : : static int s2n_stuffer_write_reservation_impl(struct s2n_stuffer_reservation *reservation, const uint32_t u)
182 : 119865 : {
183 : 119865 : reservation->stuffer->write_cursor = reservation->write_cursor;
184 [ - + ][ + - ]: 119865 : POSIX_PRECONDITION(s2n_stuffer_validate(reservation->stuffer));
185 : :
186 [ + + ]: 119865 : POSIX_GUARD(length_matches_value_check(u, reservation->length));
187 [ - + ]: 119863 : POSIX_GUARD(s2n_stuffer_write_network_order(reservation->stuffer, u, reservation->length));
188 [ - + ][ + - ]: 119863 : POSIX_POSTCONDITION(s2n_stuffer_validate(reservation->stuffer));
189 : 119863 : return S2N_SUCCESS;
190 : 119863 : }
191 : :
192 : : int s2n_stuffer_write_reservation(struct s2n_stuffer_reservation *reservation, const uint32_t u)
193 : 119869 : {
194 [ + + ][ + + ]: 119869 : POSIX_PRECONDITION(s2n_stuffer_reservation_validate(reservation));
195 : 119865 : uint32_t old_write_cursor = reservation->stuffer->write_cursor;
196 : 119865 : int result = s2n_stuffer_write_reservation_impl(reservation, u);
197 : 119865 : reservation->stuffer->write_cursor = old_write_cursor;
198 : 119865 : return result;
199 : 119869 : }
200 : :
201 : : int s2n_stuffer_get_vector_size(const struct s2n_stuffer_reservation *reservation, uint32_t *size)
202 : 119864 : {
203 [ - + ][ + - ]: 119864 : POSIX_PRECONDITION(s2n_stuffer_reservation_validate(reservation));
204 [ - + ][ # # ]: 119864 : POSIX_ENSURE_REF(size);
205 : 119864 : *size = reservation->stuffer->write_cursor - (reservation->write_cursor + reservation->length);
206 : 119864 : return S2N_SUCCESS;
207 : 119864 : }
208 : :
209 : : int s2n_stuffer_write_vector_size(struct s2n_stuffer_reservation *reservation)
210 : 112514 : {
211 : 112514 : uint32_t size = 0;
212 [ - + ]: 112514 : POSIX_GUARD(s2n_stuffer_get_vector_size(reservation, &size));
213 [ + + ]: 112514 : POSIX_GUARD(s2n_stuffer_write_reservation(reservation, size));
214 : 112512 : return S2N_SUCCESS;
215 : 112514 : }
|
