1 /* 2 * Copyright 1995-2023 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the OpenSSL license (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 <limits.h> 11 #include <stdio.h> 12 #include "internal/cryptlib.h" 13 #include <openssl/asn1.h> 14 #include "asn1_local.h" 15 16 int ASN1_BIT_STRING_set(ASN1_BIT_STRING *x, unsigned char *d, int len) 17 { 18 return ASN1_STRING_set(x, d, len); 19 } 20 21 int i2c_ASN1_BIT_STRING(ASN1_BIT_STRING *a, unsigned char **pp) 22 { 23 int ret, j, bits, len; 24 unsigned char *p, *d; 25 26 if (a == NULL) 27 return 0; 28 29 len = a->length; 30 31 if (len > 0) { 32 if (a->flags & ASN1_STRING_FLAG_BITS_LEFT) { 33 bits = (int)a->flags & 0x07; 34 } else { 35 for (; len > 0; len--) { 36 if (a->data[len - 1]) 37 break; 38 } 39 j = a->data[len - 1]; 40 if (j & 0x01) 41 bits = 0; 42 else if (j & 0x02) 43 bits = 1; 44 else if (j & 0x04) 45 bits = 2; 46 else if (j & 0x08) 47 bits = 3; 48 else if (j & 0x10) 49 bits = 4; 50 else if (j & 0x20) 51 bits = 5; 52 else if (j & 0x40) 53 bits = 6; 54 else if (j & 0x80) 55 bits = 7; 56 else 57 bits = 0; /* should not happen */ 58 } 59 } else 60 bits = 0; 61 62 ret = 1 + len; 63 if (pp == NULL) 64 return ret; 65 66 p = *pp; 67 68 *(p++) = (unsigned char)bits; 69 d = a->data; 70 if (len > 0) { 71 memcpy(p, d, len); 72 p += len; 73 p[-1] &= (0xff << bits); 74 } 75 *pp = p; 76 return ret; 77 } 78 79 ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a, 80 const unsigned char **pp, long len) 81 { 82 ASN1_BIT_STRING *ret = NULL; 83 const unsigned char *p; 84 unsigned char *s; 85 int i; 86 87 if (len < 1) { 88 i = ASN1_R_STRING_TOO_SHORT; 89 goto err; 90 } 91 92 if (len > INT_MAX) { 93 i = ASN1_R_STRING_TOO_LONG; 94 goto err; 95 } 96 97 if ((a == NULL) || ((*a) == NULL)) { 98 if ((ret = ASN1_BIT_STRING_new()) == NULL) 99 return NULL; 100 } else 101 ret = (*a); 102 103 p = *pp; 104 i = *(p++); 105 if (i > 7) { 106 i = ASN1_R_INVALID_BIT_STRING_BITS_LEFT; 107 goto err; 108 } 109 /* 110 * We do this to preserve the settings. If we modify the settings, via 111 * the _set_bit function, we will recalculate on output 112 */ 113 ret->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); /* clear */ 114 ret->flags |= (ASN1_STRING_FLAG_BITS_LEFT | i); /* set */ 115 116 if (len-- > 1) { /* using one because of the bits left byte */ 117 s = OPENSSL_malloc((int)len); 118 if (s == NULL) { 119 i = ERR_R_MALLOC_FAILURE; 120 goto err; 121 } 122 memcpy(s, p, (int)len); 123 s[len - 1] &= (0xff << i); 124 p += len; 125 } else 126 s = NULL; 127 128 ret->length = (int)len; 129 OPENSSL_free(ret->data); 130 ret->data = s; 131 ret->type = V_ASN1_BIT_STRING; 132 if (a != NULL) 133 (*a) = ret; 134 *pp = p; 135 return ret; 136 err: 137 ASN1err(ASN1_F_C2I_ASN1_BIT_STRING, i); 138 if ((a == NULL) || (*a != ret)) 139 ASN1_BIT_STRING_free(ret); 140 return NULL; 141 } 142 143 /* 144 * These next 2 functions from Goetz Babin-Ebell. 145 */ 146 int ASN1_BIT_STRING_set_bit(ASN1_BIT_STRING *a, int n, int value) 147 { 148 int w, v, iv; 149 unsigned char *c; 150 151 if (n < 0) 152 return 0; 153 154 w = n / 8; 155 v = 1 << (7 - (n & 0x07)); 156 iv = ~v; 157 if (!value) 158 v = 0; 159 160 if (a == NULL) 161 return 0; 162 163 a->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07); /* clear, set on write */ 164 165 if ((a->length < (w + 1)) || (a->data == NULL)) { 166 if (!value) 167 return 1; /* Don't need to set */ 168 c = OPENSSL_clear_realloc(a->data, a->length, w + 1); 169 if (c == NULL) { 170 ASN1err(ASN1_F_ASN1_BIT_STRING_SET_BIT, ERR_R_MALLOC_FAILURE); 171 return 0; 172 } 173 if (w + 1 - a->length > 0) 174 memset(c + a->length, 0, w + 1 - a->length); 175 a->data = c; 176 a->length = w + 1; 177 } 178 a->data[w] = ((a->data[w]) & iv) | v; 179 while ((a->length > 0) && (a->data[a->length - 1] == 0)) 180 a->length--; 181 return 1; 182 } 183 184 int ASN1_BIT_STRING_get_bit(const ASN1_BIT_STRING *a, int n) 185 { 186 int w, v; 187 188 if (n < 0) 189 return 0; 190 191 w = n / 8; 192 v = 1 << (7 - (n & 0x07)); 193 if ((a == NULL) || (a->length < (w + 1)) || (a->data == NULL)) 194 return 0; 195 return ((a->data[w] & v) != 0); 196 } 197 198 /* 199 * Checks if the given bit string contains only bits specified by 200 * the flags vector. Returns 0 if there is at least one bit set in 'a' 201 * which is not specified in 'flags', 1 otherwise. 202 * 'len' is the length of 'flags'. 203 */ 204 int ASN1_BIT_STRING_check(const ASN1_BIT_STRING *a, 205 const unsigned char *flags, int flags_len) 206 { 207 int i, ok; 208 /* Check if there is one bit set at all. */ 209 if (!a || !a->data) 210 return 1; 211 212 /* 213 * Check each byte of the internal representation of the bit string. 214 */ 215 ok = 1; 216 for (i = 0; i < a->length && ok; ++i) { 217 unsigned char mask = i < flags_len ? ~flags[i] : 0xff; 218 /* We are done if there is an unneeded bit set. */ 219 ok = (a->data[i] & mask) == 0; 220 } 221 return ok; 222 } 223