1 /*****************************************************************************
3 # Copyright 2019 AT&T Intellectual Property *
5 # Licensed under the Apache License, Version 2.0 (the "License"); *
6 # you may not use this file except in compliance with the License. *
7 # You may obtain a copy of the License at *
9 # http://www.apache.org/licenses/LICENSE-2.0 *
11 # Unless required by applicable law or agreed to in writing, software *
12 # distributed under the License is distributed on an "AS IS" BASIS, *
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
14 # See the License for the specific language governing permissions and *
15 # limitations under the License. *
17 ******************************************************************************/
20 * Copyright (c) 2005-2017 Lev Walkin <vlm@lionet.info>. All rights reserved.
21 * Redistribution and modifications are permitted subject to BSD license.
23 #include <asn_system.h>
24 #include <asn_internal.h>
25 #include <per_support.h>
28 * X.691-201508 #10.9 General rules for encoding a length determinant.
29 * Get the optionally constrained length "n" from the stream.
32 uper_get_length(asn_per_data_t *pd, int ebits, size_t lower_bound,
38 /* #11.9.4.1 Encoding if constrained (according to effective bits) */
39 if(ebits >= 0 && ebits <= 16) {
40 value = per_get_few_bits(pd, ebits);
41 if(value >= 0) value += lower_bound;
45 value = per_get_few_bits(pd, 8);
46 if((value & 0x80) == 0) { /* #11.9.3.6 */
47 return (value & 0x7F);
48 } else if((value & 0x40) == 0) { /* #11.9.3.7 */
49 /* bit 8 ... set to 1 and bit 7 ... set to zero */
50 value = ((value & 0x3f) << 8) | per_get_few_bits(pd, 8);
51 return value; /* potential -1 from per_get_few_bits passes through. */
52 } else if(value < 0) {
53 ASN_DEBUG("END of stream reached for PER");
56 value &= 0x3f; /* this is "m" from X.691, #11.9.3.8 */
57 if(value < 1 || value > 4) {
58 return -1; /* Prohibited by #11.9.3.8 */
61 return (16384 * value);
65 * Get the normally small length "n".
66 * This procedure used to decode length of extensions bit-maps
67 * for SET and SEQUENCE types.
70 uper_get_nslength(asn_per_data_t *pd) {
73 ASN_DEBUG("Getting normally small length");
75 if(per_get_few_bits(pd, 1) == 0) {
76 length = per_get_few_bits(pd, 6) + 1;
77 if(length <= 0) return -1;
78 ASN_DEBUG("l=%d", (int)length);
82 length = uper_get_length(pd, -1, 0, &repeat);
83 if(length >= 0 && !repeat) return length;
84 return -1; /* Error, or do not support >16K extensions */
89 * Get the normally small non-negative whole number.
93 uper_get_nsnnwn(asn_per_data_t *pd) {
96 value = per_get_few_bits(pd, 7);
97 if(value & 64) { /* implicit (value < 0) */
100 value |= per_get_few_bits(pd, 2);
101 if(value & 128) /* implicit (value < 0) */
107 value = per_get_few_bits(pd, 8 * value);
115 * X.691-11/2008, #11.6
116 * Encoding of a normally small non-negative whole number
119 uper_put_nsnnwn(asn_per_outp_t *po, int n) {
124 return per_put_few_bits(po, n, 7);
130 else if(n < 256 * 65536)
133 return -1; /* This is not a "normally small" value */
134 if(per_put_few_bits(po, bytes, 8))
137 return per_put_few_bits(po, n, 8 * bytes);
141 /* X.691-2008/11, #11.5.6 -> #11.3 */
142 int uper_get_constrained_whole_number(asn_per_data_t *pd, unsigned long *out_value, int nbits) {
143 unsigned long lhalf; /* Lower half of the number*/
147 half = per_get_few_bits(pd, nbits);
148 if(half < 0) return -1;
153 if((size_t)nbits > 8 * sizeof(*out_value))
154 return -1; /* RANGE */
156 half = per_get_few_bits(pd, 31);
157 if(half < 0) return -1;
159 if(uper_get_constrained_whole_number(pd, &lhalf, nbits - 31))
162 *out_value = ((unsigned long)half << (nbits - 31)) | lhalf;
167 /* X.691-2008/11, #11.5.6 -> #11.3 */
169 uper_put_constrained_whole_number_u(asn_per_outp_t *po, unsigned long v,
172 return per_put_few_bits(po, v, nbits);
174 /* Put higher portion first, followed by lower 31-bit */
175 if(uper_put_constrained_whole_number_u(po, v >> 31, nbits - 31))
177 return per_put_few_bits(po, v, 31);
182 * X.691 (08/2015) #11.9 "General rules for encoding a length determinant"
183 * Put the length "n" (or part of it) into the stream.
186 uper_put_length(asn_per_outp_t *po, size_t length, int *need_eom) {
188 if(!need_eom) need_eom = &dummy;
190 if(length <= 127) { /* #11.9.3.6 */
192 return per_put_few_bits(po, length, 8)
193 ? -1 : (ssize_t)length;
194 } else if(length < 16384) { /* #10.9.3.7 */
196 return per_put_few_bits(po, length|0x8000, 16)
197 ? -1 : (ssize_t)length;
200 *need_eom = 0 == (length & 16383);
207 return per_put_few_bits(po, 0xC0 | length, 8)
208 ? -1 : (ssize_t)(length << 14);
214 * Put the normally small length "n" into the stream.
215 * This procedure used to encode length of extensions bit-maps
216 * for SET and SEQUENCE types.
219 uper_put_nslength(asn_per_outp_t *po, size_t length) {
222 if(length == 0) return -1;
223 return per_put_few_bits(po, length - 1, 7) ? -1 : 0;
226 if(uper_put_length(po, length, &need_eom) != (ssize_t)length
228 /* This might happen in case of >16K extensions */
237 per__long_range(long lb, long ub, unsigned long *range_r) {
238 unsigned long bounds_range;
239 if((ub < 0) == (lb < 0)) {
240 bounds_range = ub - lb;
243 bounds_range = 1 + ((unsigned long)ub + (unsigned long)-(lb + 1));
245 assert(!"Unreachable");
248 *range_r = bounds_range;
253 per_long_range_rebase(long v, long lb, long ub, unsigned long *output) {
258 if(v < lb || v > ub || per__long_range(lb, ub, &range) < 0) {
264 * Fundamentally what we're doing is returning (v-lb).
265 * However, this triggers undefined behavior when the word width
266 * of signed (v) is the same as the size of unsigned (*output).
267 * In practice, it triggers the UndefinedSanitizer. Therefore we shall
268 * compute the ranges accurately to avoid C's undefined behavior.
270 if((v < 0) == (lb < 0)) {
274 unsigned long rebased = 1 + (unsigned long)-(v+1) + (unsigned long)lb;
275 assert(rebased <= range); /* By construction */
279 unsigned long rebased = 1 + (unsigned long)-(lb+1) + (unsigned long)v;
280 assert(rebased <= range); /* By construction */
284 assert(!"Unreachable");
290 per_long_range_unrebase(unsigned long inp, long lb, long ub, long *outp) {
293 if(per__long_range(lb, ub, &range) != 0) {
299 * We can encode something in the given number of bits that technically
300 * exceeds the range. This is an avenue for security errors,
301 * so we don't allow that.
306 if(inp <= LONG_MAX) {
307 *outp = (long)inp + lb;
309 *outp = (lb + LONG_MAX + 1) + (long)((inp - LONG_MAX) - 1);
316 aper_get_align(asn_per_data_t *pd) {
318 if(pd->nboff & 0x7) {
319 ASN_DEBUG("Aligning %ld bits", 8 - ((unsigned long)pd->nboff & 0x7));
320 return per_get_few_bits(pd, 8 - (pd->nboff & 0x7));
326 aper_get_length(asn_per_data_t *pd, int range, int ebits, int *repeat) {
331 if (range <= 65536 && range >= 0)
332 return aper_get_nsnnwn(pd, range);
334 if (aper_get_align(pd) < 0)
337 if(ebits >= 0) return per_get_few_bits(pd, ebits);
339 value = per_get_few_bits(pd, 8);
340 if(value < 0) return -1;
341 if((value & 128) == 0) /* #10.9.3.6 */
342 return (value & 0x7F);
343 if((value & 64) == 0) { /* #10.9.3.7 */
344 value = ((value & 63) << 8) | per_get_few_bits(pd, 8);
345 if(value < 0) return -1;
348 value &= 63; /* this is "m" from X.691, #10.9.3.8 */
349 if(value < 1 || value > 4)
352 return (16384 * value);
356 aper_get_nslength(asn_per_data_t *pd) {
359 ASN_DEBUG("Getting normally small length");
361 if(per_get_few_bits(pd, 1) == 0) {
362 length = per_get_few_bits(pd, 6) + 1;
363 if(length <= 0) return -1;
364 ASN_DEBUG("l=%ld", length);
368 length = aper_get_length(pd, -1, -1, &repeat);
369 if(length >= 0 && !repeat) return length;
370 return -1; /* Error, or do not support >16K extensions */
375 aper_get_nsnnwn(asn_per_data_t *pd, int range) {
379 ASN_DEBUG("getting nsnnwn with range %d", range);
384 if (range < 0) return -1;
386 for (i = 1; i <= 8; i++) {
391 value = per_get_few_bits(pd, i);
393 } else if (range == 256){
396 } else if (range <= 65536) {
402 if (aper_get_align(pd) < 0)
404 value = per_get_few_bits(pd, 8 * bytes);
408 int aper_put_align(asn_per_outp_t *po) {
410 if(po->nboff & 0x7) {
411 ASN_DEBUG("Aligning %ld bits", 8 - ((unsigned long)po->nboff & 0x7));
412 if(per_put_few_bits(po, 0x00, (8 - (po->nboff & 0x7))))
419 aper_put_length(asn_per_outp_t *po, int range, size_t length) {
421 ASN_DEBUG("APER put length %zu with range %d", length, range);
423 /* 10.9 X.691 Note 2 */
424 if (range <= 65536 && range >= 0)
425 return aper_put_nsnnwn(po, range, length);
427 if (aper_put_align(po) < 0)
430 if(length <= 127) /* #10.9.3.6 */{
431 return per_put_few_bits(po, length, 8)
432 ? -1 : (ssize_t)length;
434 else if(length < 16384) /* #10.9.3.7 */
435 return per_put_few_bits(po, length|0x8000, 16)
436 ? -1 : (ssize_t)length;
439 if(length > 4) length = 4;
441 return per_put_few_bits(po, 0xC0 | length, 8)
442 ? -1 : (ssize_t)(length << 14);
447 aper_put_nslength(asn_per_outp_t *po, size_t length) {
451 if(length == 0) return -1;
452 return per_put_few_bits(po, length-1, 7) ? -1 : 0;
454 if(aper_put_length(po, -1, length) != (ssize_t)length) {
455 /* This might happen in case of >16K extensions */
464 aper_put_nsnnwn(asn_per_outp_t *po, int range, int number) {
467 ASN_DEBUG("aper put nsnnwn %d with range %d", number, range);
472 int bits = 1 << (8 * i);
481 for (i = 1; i <= 8; i++) {
486 return per_put_few_bits(po, number, i);
487 } else if(range == 256) {
489 } else if(range <= 65536) {
491 } else { /* Ranges > 64K */
494 int bits = 1 << (8 * i);
501 if(aper_put_align(po) < 0) /* Aligning on octet */
503 /* if(per_put_few_bits(po, bytes, 8))
506 return per_put_few_bits(po, number, 8 * bytes);