/*

 *  Copyright (C) 2014 Cisco and/or its affiliates. All rights reserved.

 *

 *  Author: Shawn Webb

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License version 2 as

 *  published by the Free Software Foundation.

 *

 *  This program 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 General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 *  MA 02110-1301, USA.

 */

#if HAVE_CONF_H

#include "clamav-config.h"

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <math.h>

#include <sys/types.h>

#include <openssl/bio.h>

#include <openssl/evp.h>

// libclamav

#include "clamav.h"

#include "conv.h"

/** Get the expected decoded length of a base64-encoded string

 * @param[in] data Base64-encoded string

 * @param[in] len length of the string

 * @return The expected decoded length of the base64-encoded string

 */

static size_t base64_len(const char *data, size_t len)

{

    int padding = 0;

    size_t i;

    if (!len)

        return 0;

    for (i = len - 1; i > 0 && data[i] == '='; i--)

        padding++;

    return (size_t)((3 * len) / 4 - padding);

}

/** Decode a base64-encoded string

 * @param[in] data The base64-encoded string

 * @param[in] len Length of the base64-encoded string

 * @param[out] obuf If obuf is not set to NULL, store the decoded data in obuf. Otherwise, the decoded data is stored in a dynamically-allocated buffer.

 * @param[out] olen The length of the decoded data

 * @return The base64-decoded data

 */

void *cl_base64_decode(char *data, size_t len, void *obuf, size_t *olen, int oneline)

{

    BIO *bio, *b64;

    void *buf;

    buf = (obuf) ? obuf : malloc(base64_len(data, len) + 1);

    if (!(buf))

        return NULL;

    b64 = BIO_new(BIO_f_base64());

    if (!(b64)) {

        if (!(obuf))

            free(buf);

        return NULL;

    }

    bio = BIO_new_mem_buf(data, len);

    if (!(bio)) {

        BIO_free(b64);

        if (!(obuf))

            free(buf);

        return NULL;

    }

    bio = BIO_push(b64, bio);

    if (oneline)

        BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);

    *olen = BIO_read(bio, buf, base64_len(data, len));

    BIO_free_all(bio);

    return buf;

}

/** Base64-encode data

 * @param[in] data The data to be encoded

 * @param[in] len The length of the data

 * @return A pointer to the base64-encoded data. The data is stored in a dynamically-allocated buffer.

 */

char *cl_base64_encode(void *data, size_t len)

{

    BIO *bio, *b64;

    char *buf, *p;

    size_t elen;

    b64 = BIO_new(BIO_f_base64());

    if (!(b64))

        return NULL;

    bio = BIO_new(BIO_s_mem());

    if (!(bio)) {

        BIO_free(b64);

        return NULL;

    }

    bio = BIO_push(b64, bio);

    BIO_write(bio, data, len);

    BIO_flush(bio);

    elen = (size_t)BIO_get_mem_data(bio, &buf);

    /* Ensure we're dealing with a NULL-terminated string */

    p = (char *)malloc(elen + 1);

    if (NULL == p) {

        BIO_free(b64);

        return NULL;

    }

    memcpy((void *)p, (void *)buf, elen);

    p[elen] = 0x00;

    buf     = p;

    BIO_free_all(bio);

    return buf;

}

#if defined(CONV_SELF_TEST)

int main(int argc, char *argv[])

{

    char *plaintext, *encoded, *decoded;

    unsigned char *sha_plaintext, *sha_decoded;

    size_t len;

    int ret = 0;

    unsigned int shalen;

    initialize_crypto();

    plaintext     = (argv[1]) ? argv[1] : "Hello. This is dog";

    sha_plaintext = sha256(plaintext, strlen(plaintext), NULL, NULL);

    if (!(sha_plaintext)) {

        fprintf(stderr, "Could not generate sha256 of plaintext\n");

        return 1;

    }

    encoded = base64_encode(plaintext, strlen(plaintext));

    if (!(encoded)) {

        fprintf(stderr, "Could not base64 encode plaintest\n");

        return 1;

    }

    fprintf(stderr, "Base64 encoded: %s\n", encoded);

    decoded = base64_decode(encoded, strlen(encoded), NULL, &len);

    if (!(decoded)) {

        fprintf(stderr, "Could not base64 decoded string\n");

        return 1;

    }

    sha_decoded = sha256(decoded, len, NULL, &shalen);

    if (!(sha_decoded)) {

        fprintf(stderr, "Could not generate sha256 of decoded data\n");

        return 1;

    }

    if (memcmp(sha_plaintext, sha_decoded, shalen)) {

        fprintf(stderr, "Decoded does not match plaintext: %s\n", decoded);

        ret = 1;

    }

    free(sha_decoded);

    free(sha_plaintext);

    free(encoded);

    free(decoded);

    cleanup_crypto();

    return ret;

}

#endif