/*
* Copyright (C) 2007-2016 Free Software Foundation, Inc.
* Copyright (C) 2015-2016 Red Hat, Inc.
*
* Author: Simon Josefsson, Nikos Mavrogiannopoulos, Martin Ukrop
*
* This file is part of GnuTLS.
*
* The GnuTLS is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>
*
*/
#include "gnutls_int.h"
#include "ip.h"
#include <gnutls/x509.h>
#include <arpa/inet.h>
/*-
* _gnutls_mask_to_prefix:
* @mask: CIDR mask
* @mask_size: number of bytes in @mask
*
* Check for mask validity (form of 1*0*) and return its prefix numerically.
*
* Returns: Length of 1-prefix (0 -- mask_size*8), -1 in case of invalid mask
-*/
int _gnutls_mask_to_prefix(const unsigned char *mask, unsigned mask_size)
{
unsigned i, prefix_length = 0;
for (i=0; i<mask_size; i++) {
if (mask[i] == 0xFF) {
prefix_length += 8;
} else {
switch(mask[i]) {
case 0xFE: prefix_length += 7; break;
case 0xFC: prefix_length += 6; break;
case 0xF8: prefix_length += 5; break;
case 0xF0: prefix_length += 4; break;
case 0xE0: prefix_length += 3; break;
case 0xC0: prefix_length += 2; break;
case 0x80: prefix_length += 1; break;
case 0x00: break;
default:
return -1;
}
break;
}
}
i++;
// mask is invalid, if there follows something else than 0x00
for ( ; i<mask_size; i++) {
if (mask[i] != 0)
return -1;
}
return prefix_length;
}
/*-
* _gnutls_ip_to_string:
* @_ip: IP address (RFC5280 format)
* @ip_size: Size of @_ip (4 or 16)
* @out: Resulting string
* @out_size: Size of @out
*
* Transform IP address into human-readable string.
* @string must be already allocated and
* at least 16/48 bytes for IPv4/v6 address respectively.
*
* Returns: Address of result string.
-*/
const char *_gnutls_ip_to_string(const void *_ip, unsigned int ip_size, char *out, unsigned int out_size)
{
if (ip_size != 4 && ip_size != 16) {
gnutls_assert();
return NULL;
}
if (ip_size == 4 && out_size < 16) {
gnutls_assert();
return NULL;
}
if (ip_size == 16 && out_size < 48) {
gnutls_assert();
return NULL;
}
if (ip_size == 4)
return inet_ntop(AF_INET, _ip, out, out_size);
else
return inet_ntop(AF_INET6, _ip, out, out_size);
}
/*-
* _gnutls_cidr_to_string:
* @_ip: CIDR range (RFC5280 format)
* @ip_size: Size of @_ip (8 or 32)
* @out: Resulting string
* @out_size: Size of @out
*
* Transform CIDR IP address range into human-readable string.
* The input @_ip must be in RFC5280 format (IP address in network byte
* order, followed by its network mask which is 4 bytes in IPv4 and
* 16 bytes in IPv6). @string must be already allocated and
* at least 33/97 bytes for IPv4/v6 address respectively.
*
* Returns: Address of result string.
-*/
const char *_gnutls_cidr_to_string(const void *_ip, unsigned int ip_size, char *out, unsigned int out_size)
{
const unsigned char *ip = _ip;
char tmp[64];
const char *p;
if (ip_size != 8 && ip_size != 32) {
gnutls_assert();
return NULL;
}
if (ip_size == 8) {
p = inet_ntop(AF_INET, ip, tmp, sizeof(tmp));
if (p)
snprintf(out, out_size, "%s/%d", tmp, _gnutls_mask_to_prefix(ip+4, 4));
} else {
p = inet_ntop(AF_INET6, ip, tmp, sizeof(tmp));
if (p)
snprintf(out, out_size, "%s/%d", tmp, _gnutls_mask_to_prefix(ip+16, 16));
}
if (p == NULL)
return NULL;
return out;
}
static void prefix_to_mask(unsigned prefix, unsigned char *mask, size_t mask_size)
{
int i;
unsigned j;
memset(mask, 0, mask_size);
for (i = prefix, j = 0; i > 0 && j < mask_size; i -= 8, j++) {
if (i >= 8) {
mask[j] = 0xff;
} else {
mask[j] = (unsigned long)(0xffU << (8 - i));
}
}
}
/*-
* _gnutls_mask_ip:
* @ip: IP of @ipsize bytes
* @mask: netmask of @ipsize bytes
* @ipsize: IP length (4 or 16)
*
* Mask given IP in place according to the given mask.
*
* Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a negative error value.
-*/
int _gnutls_mask_ip(unsigned char *ip, const unsigned char *mask, unsigned ipsize)
{
unsigned i;
if (ipsize != 4 && ipsize != 16)
return GNUTLS_E_MALFORMED_CIDR;
for (i = 0; i < ipsize; i++)
ip[i] &= mask[i];
return GNUTLS_E_SUCCESS;
}
/**
* gnutls_x509_cidr_to_rfc5280:
* @cidr: CIDR in RFC4632 format (IP/prefix), null-terminated
* @cidr_rfc5280: CIDR range converted to RFC5280 format
*
* This function will convert text CIDR range with prefix (such as '10.0.0.0/8')
* to RFC5280 (IP address in network byte order followed by its network mask).
* Works for both IPv4 and IPv6.
*
* The resulting object is directly usable for IP name constraints usage,
* for example in functions %gnutls_x509_name_constraints_add_permitted
* or %gnutls_x509_name_constraints_add_excluded.
*
* The data in datum needs to be deallocated using gnutls_free().
*
* Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, otherwise a negative error value.
*
* Since: 3.5.4
*/
int gnutls_x509_cidr_to_rfc5280(const char *cidr, gnutls_datum_t *cidr_rfc5280)
{
unsigned iplength, prefix;
int ret;
char *p;
char *p_end = NULL;
char *cidr_tmp;
p = strchr(cidr, '/');
if (p != NULL) {
prefix = strtol(p+1, &p_end, 10);
if (prefix == 0 && p_end == p+1) {
_gnutls_debug_log("Cannot parse prefix given in CIDR %s\n", cidr);
gnutls_assert();
return GNUTLS_E_MALFORMED_CIDR;
}
unsigned length = p-cidr+1;
cidr_tmp = gnutls_malloc(length);
if (cidr_tmp == NULL) {
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
}
memcpy(cidr_tmp, cidr, length);
cidr_tmp[length-1] = 0;
} else {
_gnutls_debug_log("No prefix given in CIDR %s\n", cidr);
gnutls_assert();
return GNUTLS_E_MALFORMED_CIDR;
}
if (strchr(cidr, ':') != 0) { /* IPv6 */
iplength = 16;
} else { /* IPv4 */
iplength = 4;
}
cidr_rfc5280->size = 2*iplength;
if (prefix > iplength*8) {
_gnutls_debug_log("Invalid prefix given in CIDR %s (%d)\n", cidr, prefix);
ret = gnutls_assert_val(GNUTLS_E_MALFORMED_CIDR);
goto cleanup;
}
cidr_rfc5280->data = gnutls_malloc(cidr_rfc5280->size);
if (cidr_rfc5280->data == NULL) {
ret = gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
goto cleanup;
}
ret = inet_pton(iplength == 4 ? AF_INET : AF_INET6, cidr_tmp, cidr_rfc5280->data);
if (ret == 0) {
_gnutls_debug_log("Cannot parse IP from CIDR %s\n", cidr_tmp);
ret = gnutls_assert_val(GNUTLS_E_MALFORMED_CIDR);
goto cleanup;
}
prefix_to_mask(prefix, &cidr_rfc5280->data[iplength], iplength);
_gnutls_mask_ip(cidr_rfc5280->data, &cidr_rfc5280->data[iplength], iplength);
ret = GNUTLS_E_SUCCESS;
cleanup:
gnutls_free(cidr_tmp);
return ret;
}