char *Encryption::Encrypt(const char* buffer, unsigned int buffer_size, unsigned int &out_size)
{
if(encrypt_func)
{
return encrypt_func(buffer, buffer_size, out_size);
}
return NULL;
}
static ssize_t
purple_aes_cipher_encrypt(PurpleCipher *cipher, const guchar input[],
size_t in_len, guchar output[], size_t out_size)
{
PurpleAESCipherPrivate *priv = PURPLE_AES_CIPHER_GET_PRIVATE(cipher);
purple_aes_cipher_crypt_func encrypt_func;
guchar *input_padded;
size_t out_len = 0;
gboolean succ;
if (priv->failure)
return -1;
input_padded = purple_aes_cipher_pad_pkcs7(input, in_len, &out_len);
if (out_len > out_size) {
purple_debug_error("cipher-aes", "Output buffer too small (%"
G_GSIZE_FORMAT " > %" G_GSIZE_FORMAT ")",
out_len, out_size);
memset(input_padded, 0, out_len);
g_free(input_padded);
return -1;
}
#if defined(PURPLE_AES_USE_GNUTLS)
encrypt_func = purple_aes_cipher_gnutls_encrypt;
#elif defined(PURPLE_AES_USE_NSS)
encrypt_func = purple_aes_cipher_nss_encrypt;
#else
purple_debug_error("cipher-aes", "No matching encrypt_func\n");
return -1;
#endif
succ = encrypt_func(input_padded, output, out_len, priv->iv,
priv->key, priv->key_size, priv->batch_mode);
memset(input_padded, 0, out_len);
g_free(input_padded);
if (!succ) {
memset(output, 0, out_len);
return -1;
}
return out_len;
}
static fru_errno_t
frt_for_each_packet(fru_seghdl_t node,
int (*function)(fru_tag_t *tag, uint8_t *payload, size_t length,
void *args), void *args)
{
int rc_num;
int status;
char *rc_tags;
char *rc_data;
int i;
packet_t *packets = NULL;
segment_list_t *tmp_list;
fru_segdesc_t *descriptor;
tmp_list = g_raw->segs;
/* num of packet */
rc_num = fru_get_num_packets(node, NULL);
if (rc_num == -1) {
return (map_errno(errno));
} else if (rc_num == 0) {
return (FRU_SUCCESS);
}
while (tmp_list) {
if (node == tmp_list->segment->handle) {
break;
}
tmp_list = tmp_list->next;
}
if (tmp_list) {
descriptor = (fru_segdesc_t *)&tmp_list->segment->descriptor;
if (descriptor->field.opaque) {
return (FRU_SUCCESS);
}
if (descriptor->field.encrypted && (encrypt_func == NULL)) {
return (FRU_SUCCESS);
}
}
packets = malloc(sizeof (*packets) * (rc_num));
if (packets == NULL) {
return (FRU_FAILURE);
}
/* get all packets */
if (fru_get_packets(node, packets, rc_num, NULL) == -1) {
free(packets);
return (map_errno(errno));
}
rc_tags = malloc(sizeof (*rc_tags) * (rc_num));
if (rc_tags == NULL) {
free(packets);
return (FRU_FAILURE);
}
/* number of tags */
for (i = 0; i < rc_num; i++) {
size_t rc_len =
get_payload_length((fru_tag_t *)&packets[i].tag);
rc_data = malloc(sizeof (*rc_data) * (rc_len));
if (rc_data == NULL) {
free(packets);
return (FRU_FAILURE);
}
/* get the payload data */
(void) fru_get_payload(packets[i].handle, (void *)rc_data,
rc_len, NULL);
if (tmp_list) {
descriptor =
(fru_segdesc_t *)&tmp_list->segment->descriptor;
if ((descriptor->field.encrypted) &&
((status = encrypt_func(FRU_DECRYPT,
(void *)rc_data, rc_len))
!= FRU_SUCCESS)) {
return (status);
}
}
/* print packet */
if ((status = function((fru_tag_t *)&packets[i].tag,
(uint8_t *)rc_data, rc_len, args)) != FRU_SUCCESS) {
free(rc_data);
free(packets);
return (status);
}
free(rc_data);
}
return (FRU_SUCCESS);
}
