/* returns ciphertext which contains the headers too. This also
* calculates the size in the header field.
*
* If random pad != 0 then the random pad data will be appended.
*/
int
_gnutls_encrypt (gnutls_session_t session, const opaque * headers,
size_t headers_size, const opaque * data,
size_t data_size, opaque * ciphertext,
size_t ciphertext_size, content_type_t type,
record_parameters_st * params)
{
gnutls_datum_t comp;
int free_comp = 0;
int ret;
if (data_size == 0 || is_write_comp_null (params) == 0)
{
comp.data = (opaque*)data;
comp.size = data_size;
}
else
{
/* Here comp is allocated and must be
* freed.
*/
free_comp = 1;
comp.size = ciphertext_size - headers_size;
comp.data = gnutls_malloc(comp.size);
if (comp.data == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
ret = _gnutls_compress( ¶ms->write.compression_state, data, data_size, comp.data, comp.size);
if (ret < 0)
{
gnutls_free(comp.data);
return gnutls_assert_val(ret);
}
comp.size = ret;
}
ret = compressed_to_ciphertext (session, &ciphertext[headers_size],
ciphertext_size - headers_size,
&comp, type, params);
if (free_comp)
gnutls_free(comp.data);
if (ret < 0)
return gnutls_assert_val(ret);
/* copy the headers */
memcpy (ciphertext, headers, headers_size);
if(IS_DTLS(session))
_gnutls_write_uint16 (ret, &ciphertext[11]);
else
_gnutls_write_uint16 (ret, &ciphertext[3]);
return ret + headers_size;
}
/* returns ciphertext which contains the headers too. This also
* calculates the size in the header field.
*
* If random pad != 0 then the random pad data will be appended.
*/
int
_gnutls_encrypt (gnutls_session_t session, const opaque * headers,
size_t headers_size, const opaque * data,
size_t data_size, opaque * ciphertext,
size_t ciphertext_size, content_type_t type, int random_pad,
record_parameters_st * params)
{
gnutls_datum_t plain;
gnutls_datum_t comp;
int ret;
int free_comp = 1;
plain.data = (opaque *) data;
plain.size = data_size;
if (plain.size == 0 || is_write_comp_null (session) == 0)
{
comp = plain;
free_comp = 0;
}
else
{
/* Here comp is allocated and must be
* freed.
*/
ret = _gnutls_m_plaintext2compressed (session, &comp, &plain, params);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
}
ret = _gnutls_compressed2ciphertext (session, &ciphertext[headers_size],
ciphertext_size - headers_size,
comp, type, random_pad, params);
if (free_comp)
_gnutls_free_datum (&comp);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* copy the headers */
memcpy (ciphertext, headers, headers_size);
_gnutls_write_uint16 (ret, &ciphertext[3]);
return ret + headers_size;
}
/* returns ciphertext which contains the headers too. This also
* calculates the size in the header field.
*
*/
int
_gnutls_encrypt(gnutls_session_t session,
const uint8_t * data, size_t data_size,
size_t min_pad,
mbuffer_st * bufel,
content_type_t type, record_parameters_st * params)
{
gnutls_datum_t comp;
int free_comp = 0;
int ret;
if (data_size == 0 || is_write_comp_null(params) == 0) {
comp.data = (uint8_t *) data;
comp.size = data_size;
} else {
/* Here comp is allocated and must be
* freed.
*/
free_comp = 1;
comp.size = _mbuffer_get_udata_size(bufel);
comp.data = gnutls_malloc(comp.size);
if (comp.data == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
ret =
_gnutls_compress(¶ms->write.compression_state,
data, data_size, comp.data, comp.size,
session->internals.priorities.
stateless_compression);
if (ret < 0) {
gnutls_free(comp.data);
return gnutls_assert_val(ret);
}
comp.size = ret;
}
ret =
compressed_to_ciphertext(session,
_mbuffer_get_udata_ptr(bufel),
_mbuffer_get_udata_size
(bufel), &comp, min_pad, type,
params);
if (free_comp)
gnutls_free(comp.data);
if (ret < 0)
return gnutls_assert_val(ret);
if (IS_DTLS(session))
_gnutls_write_uint16(ret,
((uint8_t *)
_mbuffer_get_uhead_ptr(bufel)) + 11);
else
_gnutls_write_uint16(ret,
((uint8_t *)
_mbuffer_get_uhead_ptr(bufel)) + 3);
_mbuffer_set_udata_size(bufel, ret);
_mbuffer_set_uhead_size(bufel, 0);
return _mbuffer_get_udata_size(bufel);
}
