/*
 * Copyright (c) 2012-2020 MIRACL UK Ltd.
 *
 * This file is part of MIRACL Core
 * (see https://github.com/miracl/core).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*** Basic Octet string maintainance routines  ***/
/* SU=m, m is Stack Usage */

#include <string.h>
#include "core.h"

#ifdef CORE_ARDUINO
#include <Arduino.h>
#endif

using namespace core;

/* Output an octet string (Debug Only) */

/* SU= 16 */
/* output octet */
void core::OCT_output(octet *w)
{
    int i;
    unsigned char ch;
    for (i = 0; i < w->len; i++)
    {
        ch = w->val[i];
#ifdef CORE_ARDUINO
        char my_data[3];
        sprintf(my_data, "%02x", ch);
        Serial.print(my_data);
#else
        printf("%02x", ch);
#endif
    }
#ifdef CORE_ARDUINO
    Serial.println("");
#else
    printf("\n");
#endif
}

/* reverse bytes. Useful if dealing with those little-endian bastards */
void core::OCT_reverse(octet *w)
{
    int i;
    unsigned char ch;
    for (i = 0; i < w->len/2; i++) { 
        ch = w->val[i]; 
        w->val[i] = w->val[w->len - i - 1]; 
        w->val[w->len - i - 1] = ch; 
    } 
}

//#define PUT_IN_SPACES

/* SU= 16 */
void core::OCT_output_string(octet *w)
{
    int i;
    unsigned char ch;
    for (i = 0; i < w->len; i++)
    {

        ch = w->val[i];
#ifdef CORE_ARDUINO
        char my_data[3];
#ifdef PUT_IN_SPACES
        sprintf(my_data, "%c ", ch);
#else
        sprintf(my_data, "%c", ch);
#endif
        Serial.print(my_data);
#else
#ifdef PUT_IN_SPACES
        printf("%c ", ch);
#else
        printf("%c", ch);
#endif
#endif
    }
}

/* Convert C string to octet format - truncates if no room  */
void core::OCT_jstring(octet *y, char *s)
{
    int i, j;
    i = y->len;
    j = 0;
    while (s[j] != 0 && i < y->max)
    {
        y->val[i] = s[j];
        y->len++;
        i++;
        j++;
    }
}

/* compare 2 octet strings.
 * If x==y return TRUE, else return FALSE */
/* SU= 8 */
int core::OCT_comp(octet *x, octet *y)
{
    int i;
    if (x->len > y->len) return 0;
    if (x->len < y->len) return 0;
    for (i = 0; i < x->len; i++)
    {
        if (x->val[i] != y->val[i]) return 0;
    }
    return 1;
}

/* check are first n bytes the same (in constant time) */

int core::OCT_ncomp(octet *x, octet *y, int n)
{
    int i, res = 0;
    if (n > y->len || n > x->len) return 0;
    for (i = 0; i < n; i++)
    {
        res |= (int)(x->val[i] ^ y->val[i]);
    }
    if (res == 0) return 1;
    return 0;
}

/* Shift octet to the left by n bytes. Leftmost bytes disappear  */
void core::OCT_shl(octet *x, int n)
{
    int i;
    if (n >= x->len)
    {
        x->len = 0;
        return;
    }
    x->len -= n;
    for (i = 0; i < x->len; i++)
        x->val[i] = x->val[i + n];
}

/* Append binary string to octet - truncates if no room */
/* SU= 12 */
void core::OCT_jbytes(octet *y, char *b, int len)
{
    int i, j;
    i = y->len;
    for (j = 0; j < len && i < y->max; j++)
    {
        y->val[i] = b[j];
        y->len++;
        i++;
    }
}

/* Concatenates two octet strings */
/* SU= 8 */
void core::OCT_joctet(octet *y, octet *x)
{
    /* y=y || x */
    int i, j;
    if (x == NULL) return;

    for (i = 0; i < x->len; i++)
    {
        j = y->len + i;
        if (j >= y->max)
        {
            y->len = y->max;
            return;
        }
        y->val[j] = x->val[i];
    }
    y->len += x->len;
}

/* Append byte to octet rep times */
/* SU= 8 */
void core::OCT_jbyte(octet *y, int ch, int rep)
{
    int i, j;
    i = y->len;
    for (j = 0; j < rep && i < y->max; j++)
    {
        y->val[i] = ch;
        y->len++;
        i++;
    }
}

/* XOR common bytes of x with y */
/* SU= 8 */
void core::OCT_xor(octet *y, octet *x)
{
    /* xor first x->len bytes of y */

    int i;
    for (i = 0; i < x->len && i < y->len; i++)
    {
        y->val[i] ^= x->val[i];
    }
}

/* clear an octet */
void core::OCT_empty(octet *w)
{
    w->len = 0;
}

/* Kill an octet string - Zeroise it for security */
void core::OCT_clear(octet *w)
{
    int i;
    for (i = 0; i < w->max; i++) w->val[i] = 0;
    w->len = 0;
}

/* appends int x of length len bytes to OCTET string */
/* SU= 8 */
void core::OCT_jint(octet *y, unsigned int x, int len)
{
    int i, n;
    n = y->len + len;
    if (n > y->max || len <= 0) return;
    for (i = y->len; i < n; i++) y->val[i] = 0;
    y->len = n;

    i = y->len;
    while (x > 0 && i > 0)
    {
        i--;
        y->val[i] = x % 256;
        x /= 256;
    }
}

/* Pad an octet to a given length */
/* SU= 8 */
int core::OCT_pad(octet *w, int n)
{
    int i, d;
    if (w->len > n || n > w->max) return 0;
    if (n == w->len) return 1;
    d = n - w->len;
    for (i = n - 1; i >= d; i--)
        w->val[i] = w->val[i - d];
    for (i = d - 1; i >= 0; i--)
        w->val[i] = 0;
    w->len = n;
    return 1;
}


/* Convert an octet string to base64 string */
/* SU= 56 */
void core::OCT_tobase64(char *b, octet *w)
{
    int i, j, k, rem, last;
    int c, ch[4];
    unsigned char ptr[3];
    rem = w->len % 3;
    j = k = 0;
    last = 4;
    while (j < w->len)
    {
        for (i = 0; i < 3; i++)
        {
            if (j < w->len) ptr[i] = w->val[j++];
            else
            {
                ptr[i] = 0;
                last--;
            }
        }
        ch[0] = (ptr[0] >> 2) & 0x3f;
        ch[1] = ((ptr[0] << 4) | (ptr[1] >> 4)) & 0x3f;
        ch[2] = ((ptr[1] << 2) | (ptr[2] >> 6)) & 0x3f;
        ch[3] = ptr[2] & 0x3f;
        for (i = 0; i < last; i++)
        {
            c = ch[i];
            if (c < 26) c += 65;
            if (c >= 26 && c < 52) c += 71;
            if (c >= 52 && c < 62) c -= 4;
            if (c == 62) c = '+';
            if (c == 63) c = '/';
            b[k++] = c;
        }
    }
    if (rem > 0) for (i = rem; i < 3; i++) b[k++] = '=';
    b[k] = '\0'; /* dangerous! */
}

/* SU= 56 */
void core::OCT_frombase64(octet *w, char *b)
{
    int i, j, k, pads, len = (int)strlen(b);
    int c, ch[4], ptr[3];
    j = k = 0;
    while (j < len && k < w->max)
    {
        pads = 0; i=0;
        while (i<4)
        {
            c = 80 + b[j++];
            if (c <= 112) continue; /* ignore white space */
            if (c > 144 && c < 171) c -= 145;
            if (c > 176 && c < 203) c -= 151;
            if (c > 127 && c < 138) c -= 76;
            if (c == 123) c = 62;
            if (c == 127) c = 63;
            if (c == 141)
            {
                pads++;    /* ignore pads '=' */
                i++;
                continue;
            }
            ch[i++] = c;
        }
        ptr[0] = (ch[0] << 2) | (ch[1] >> 4);
        ptr[1] = (ch[1] << 4) | (ch[2] >> 2);
        ptr[2] = (ch[2] << 6) | ch[3];
        for (i = 0; i < 3 - pads && k < w->max; i++)
        {
            /* don't put in leading zeros */
            w->val[k++] = ptr[i];
        }

    }
    w->len = k;
}

/* copy an octet string - truncates if no room */
/* SU= 16 */
void core::OCT_copy(octet *y, octet *x)
{
    int i;
    OCT_clear(y);
    y->len = x->len;
    if (y->len > y->max) y->len = y->max;

    for (i = 0; i < y->len; i++)
        y->val[i] = x->val[i];
}

/* XOR m with all of x */
void core::OCT_xorbyte(octet *x, int m)
{
    int i;
    for (i = 0; i < x->len; i++) x->val[i] ^= m;
}

/* truncates x to n bytes and places the rest in y (if y is not NULL) */
/* SU= 8 */
void core::OCT_chop(octet *x, octet *y, int n)
{
    int i;
    if (n >= x->len)
    {
        if (y != NULL) y->len = 0;
        return;
    }
    if (y != NULL) y->len = x->len - n;
    x->len = n;

    if (y != NULL)
    {
        for (i = 0; i < y->len && i < y->max; i++) y->val[i] = x->val[i + n];
    }
}

/* set x to len random bytes */
void core::OCT_rand(octet *x, csprng *RNG, int len)
{
    int i;
    if (len > x->max) len = x->max;
    x->len = len;

    for (i = 0; i < len; i++) x->val[i] = RAND_byte(RNG);
}

/* Convert an octet to a hex string */
void core::OCT_toHex(octet *src, char *dst)
{
    int i,len=src->len;
    unsigned char ch;
    for (i = 0; i < len; i++)
    {
        ch = src->val[i];
        sprintf(&dst[i * 2], "%02x", ch);
    }
    dst[2*len]='\0';
}

static int char2int(char input)
{
    if (input >= '0' && input <= '9')
        return input - '0';
    if (input >= 'A' && input <= 'F')
        return input - 'A' + 10;
    if (input >= 'a' && input <= 'f')
        return input - 'a' + 10;
    return 0;
}

/* Convert from a hex string */
void core::OCT_fromHex(octet *dst, char *src)
{
    int i = 0;
    int j = 0;
    OCT_clear(dst);
    while (src[j] != 0)
    {
        dst->val[i++] = char2int(src[j]) * 16 + char2int(src[j + 1]);
        j += 2;
    }
    dst->len = i;
}


/* Convert an octet to a string */
void core::OCT_toStr(octet *src, char *dst)
{
    int i;
    unsigned char ch;
    for (i = 0; i < src->len; i++)
    {
        ch = src->val[i];
        sprintf(&dst[i], "%c", ch);
    }
}