/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */

/*
 * XSEC
 *
 * XSECCryptoUtils:= Helper crypo utilities that make life easier
 *
 * Author(s): Berin Lautenbach
 *
 * $Id$
 *
 */

#include <xsec/framework/XSECDefs.hpp>
#include <xsec/framework/XSECError.hpp>
#include <xsec/enc/XSECCryptoUtils.hpp>
#include <xsec/enc/XSECCryptoKeyHMAC.hpp>
#include <xsec/utils/XSECPlatformUtils.hpp>

#include "../utils/XSECAlgorithmSupport.hpp"
#include "../utils/XSECAutoPtr.hpp"
#include "../utils/XSECDOMUtils.hpp"

#include <xercesc/util/Janitor.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/XMLUniDefs.hpp>

XERCES_CPP_NAMESPACE_USE

#ifdef XSEC_XKMS_ENABLED

// --------------------------------------------------------------------------------
//           XKMS Limited-Use Shared Secret handling
// --------------------------------------------------------------------------------

int CleanXKMSPassPhrase(unsigned char * input, int inputLen, safeBuffer &output) {

    // Now obsolete - use SASLCleanXKMSPassPhrase instead
    int j = 0;
    unsigned char c;
    for (int i = 0; i < inputLen; ++i) {

        c = input[i];

        if (c >= 'A' && c <= 'Z') {
            output[j++] = c - 'A' + 'a';
        }
        else if (c != '\n' && c != '\r' && c != '\t' && c != ' ') {
            output[j++] = c;
        }

    }

    return j;

}

int SASLCleanXKMSPassPhrase(unsigned char * input, int inputLen, safeBuffer &output) {

    // For now - this does *not* implement the full SASLPrep algorithm.
    // THe NFKC form is not trivial to implement - so this is kept very simple.
    // TODO - Fix this - it can be an interoperability issue as pass phrases from
    // different implementations could be treated differently.
    // Currently we only check for prohibited unput for chars < 0xFFFF and drop any
    // chars over 0xFFFF

    unsigned char * inp = new unsigned char[inputLen + 1];
    ArrayJanitor<unsigned char> j_inp(inp);
    memcpy(inp, input, inputLen);
    inp[inputLen] = '\0';

    XSECAutoPtrXMLCh uinput((char *) inp);
    XMLSize_t l = XMLString::stringLen(uinput.get());
    XMLCh* uoutput = new XMLCh[l + 1];
    ArrayJanitor<XMLCh> j_uoutput(uoutput);

    XMLSize_t i, j;
    j = 0;

    XMLCh ch1;

    for (i = 0; i < l; ++i) {

        ch1 = uinput.get()[i];
        // Case one - char is < 0x10000
        if (ch1 < 0xD800 || ch1 > 0xDFFF) {

            // OK - ch1 is "real" value - let's see if it is legal
            // The following switch tables are derived from
            // RFC 3454 - see http://www.ietf.org/rfc/rfc3454.txt

            // Non-ASCII Spaces - C.1.2
            switch (ch1) {

            case 0x00A0:        // NO-BREAK SPACE
            case 0x1680:        // OGHAM SPACE MARK
            case 0x2000:        // EN QUAD
            case 0x2001:        // EM QUAD
            case 0x2002:        // EN SPACE
            case 0x2003:        // EM SPACE
            case 0x2004:        // THREE-PER-EM SPACE
            case 0x2005:        // FOUR-PER-EM SPACE
            case 0x2006:        // SIX-PER-EM SPACE
            case 0x2007:        // FIGURE SPACE
            case 0x2008:        // PUNCTUATION SPACE
            case 0x2009:        // THIN SPACE
            case 0x200A:        // HAIR SPACE
            case 0x200B:        // ZERO WIDTH SPACE
            case 0x202F:        // NARROW NO-BREAK SPACE
            case 0x205F:        // MEDIUM MATHEMATICAL SPACE
            case 0x3000:        // IDEOGRAPHIC SPACE

                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - Non ASCII space character in XKMS pass phrase");
            default:

                break;

            }

            // ASCII Control characters
            // Note - us unsigned, so always >= 0)
            if ((ch1 <= 0x1F) || (ch1 == 0x7F)) {
                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - ASCII control character in XKMS pass phrase");
            }

            // Non-ASCII Control Characters
            if ((ch1 >= 0x80 && ch1 <= 0x9F) ||
                (ch1 >= 0x206A && ch1 <= 0x206F) ||
                (ch1 >= 0xFFF9 && ch1 <= 0xFFFC)) {

                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - NON ASCII control character in XKMS pass phrase");
            }

            switch (ch1) {


            case 0x06DD:        // ARABIC END OF AYAH
            case 0x070F:        // SYRIAC ABBREVIATION MARK
            case 0x180E:        // MONGOLIAN VOWEL SEPARATOR
            case 0x200C:        // ZERO WIDTH NON-JOINER
            case 0x200D:        // ZERO WIDTH JOINER
            case 0x2028:        // LINE SEPARATOR
            case 0x2029:        // PARAGRAPH SEPARATOR
            case 0x2060:        // WORD JOINER
            case 0x2061:        // FUNCTION APPLICATION
            case 0x2062:        // INVISIBLE TIMES
            case 0x2063:        // INVISIBLE SEPARATOR
            case 0xFEFF:        // ZERO WIDTH NO-BREAK SPACE
                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - NON ASCII control character in XKMS pass phrase");
            default:
                break;            }
            // 1D173-1D17A; [MUSICAL CONTROL CHARACTERS] is not relevant as we are looking at
            // ch1 at the moment

            // Private Use characters
            if ((ch1 >= 0xE000 && ch1 <= 0xF8FF)) {

                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - Private Use character in XKMS pass phrase");
            }

            // Non-character code points
            if ((ch1 >= 0xFDD0 && ch1 <= 0xFDEF) ||
                (ch1 >= 0xFFFE)) {

                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - Non-character code points in XKMS pass phrase");
            }

            // Inappropriate for plain text characters
   
            switch (ch1) {
            case 0xFFF9:        // INTERLINEAR ANNOTATION ANCHOR
            case 0xFFFA:        // INTERLINEAR ANNOTATION SEPARATOR
            case 0xFFFB:        // INTERLINEAR ANNOTATION TERMINATOR
            case 0xFFFC:        // OBJECT REPLACEMENT CHARACTER
            case 0xFFFD:        // REPLACEMENT CHARACTER
                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - Innappropriate for plain text chararcters in XKMS pass phrase");
            default:
                break;
            }

            // Inappripriate for canonical representation characters
            if (ch1 >= 0x2FF0 && ch1 <= 0x2FFB) {
                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - Innappropriate for canonicalisation chararcters in XKMS pass phrase");
            }

            // Change display properties or are deprecated
            switch (ch1) {
            case 0x0340:        // COMBINING GRAVE TONE MARK
            case 0x0341:        // COMBINING ACUTE TONE MARK
            case 0x200E:        // LEFT-TO-RIGHT MARK
            case 0x200F:        // RIGHT-TO-LEFT MARK
            case 0x202A:        // LEFT-TO-RIGHT EMBEDDING
            case 0x202B:        // RIGHT-TO-LEFT EMBEDDING
            case 0x202C:        // POP DIRECTIONAL FORMATTING
            case 0x202D:        // LEFT-TO-RIGHT OVERRIDE
            case 0x202E:        // RIGHT-TO-LEFT OVERRIDE
            case 0x206A:        // INHIBIT SYMMETRIC SWAPPING
            case 0x206B:        // ACTIVATE SYMMETRIC SWAPPING
            case 0x206C:        // INHIBIT ARABIC FORM SHAPING
            case 0x206D:        // ACTIVATE ARABIC FORM SHAPING
            case 0x206E:        // NATIONAL DIGIT SHAPES
            case 0x206F:        // NOMINAL DIGIT SHAPES
                throw XSECException(XSECException::XKMSError,
                    "SASLCleanXKMSPassPhrase - change display or deprecated chararcters in XKMS pass phrase");
            default:
                break;
            }

            // We got this far = just run with it for now
            uoutput[j++] = ch1;
        }
        else {
            throw XSECException(XSECException::XKMSError,
                "SASLCleanXKMSPassPhrase - don't support XKMS pass phrase chars > 0xFFFF");
        }
    } /* for */
    uoutput[j++] = chNull;

    // Now transcode
    char * utf8output= transcodeToUTF8(uoutput);
    output.sbStrcpyIn(utf8output);

    int ret = (int)strlen(utf8output);
    XSEC_RELEASE_XMLCH(utf8output);
    return ret;
}

int XSEC_EXPORT CalculateXKMSAuthenticationKey(unsigned char * input, int inputLen, unsigned char * output, int maxOutputLen) {

    unsigned char keyVal[] = {XKMSAuthenticationValue};

    XSECCryptoKeyHMAC * k = XSECPlatformUtils::g_cryptoProvider->keyHMAC();
    Janitor<XSECCryptoKeyHMAC> j_k(k);
    k->setKey(keyVal, 1);

    XSECCryptoHash *h = XSECPlatformUtils::g_cryptoProvider->HMAC(XSECCryptoHash::HASH_SHA1);
    Janitor<XSECCryptoHash> j_h(h);
    h->setKey(k);

    // Clean the input
    safeBuffer sb;
    int l = SASLCleanXKMSPassPhrase(input, inputLen, sb);

    h->hash((unsigned char *) sb.rawBuffer(), l);
    return h->finish(output, maxOutputLen);

}


int XSEC_EXPORT CalculateXKMSRevocationCodeIdentifierEncoding1(unsigned char * input, int inputLen, unsigned char * output, int maxOutputLen) {

    unsigned char keyVal[] = {XKMSRevocationCodeIdenfitierEncoding1};

    XSECCryptoKeyHMAC * k = XSECPlatformUtils::g_cryptoProvider->keyHMAC();
    Janitor<XSECCryptoKeyHMAC> j_k(k);
    k->setKey(keyVal, 1);

    XSECCryptoHash *h = XSECPlatformUtils::g_cryptoProvider->HMAC(XSECCryptoHash::HASH_SHA1);
    Janitor<XSECCryptoHash> j_h(h);

    h->setKey(k);

    // Clean the input
    safeBuffer sb;
    int l = CleanXKMSPassPhrase(input, inputLen, sb);

    h->hash((unsigned char *) sb.rawBuffer(), l);
    return h->finish(output, maxOutputLen);

}

int XSEC_EXPORT CalculateXKMSRevocationCodeIdentifierEncoding2(unsigned char * input, int inputLen, unsigned char * output, int maxOutputLen) {


    unsigned char tmpBuf[XSEC_MAX_HASH_SIZE];
    int tmpLen = CalculateXKMSRevocationCodeIdentifierEncoding1(input, inputLen, tmpBuf, XSEC_MAX_HASH_SIZE);
    return CalculateXKMSRevocationCodeIdentifierEncoding2From1(tmpBuf, tmpLen, output, maxOutputLen);

}

int XSEC_EXPORT CalculateXKMSRevocationCodeIdentifierEncoding2From1(unsigned char * input, int inputLen, unsigned char * output, int maxOutputLen) {

    unsigned char keyVal[] = {XKMSRevocationCodeIdenfitierEncoding2};

    XSECCryptoKeyHMAC * k = XSECPlatformUtils::g_cryptoProvider->keyHMAC();
    Janitor<XSECCryptoKeyHMAC> j_k(k);
    k->setKey(keyVal, 1);

    XSECCryptoHash *h = XSECPlatformUtils::g_cryptoProvider->HMAC(XSECCryptoHash::HASH_SHA1);
    Janitor<XSECCryptoHash> j_h(h);

    h->setKey(k);

    h->hash(input, inputLen);
    return h->finish(output, maxOutputLen);

}

int XSEC_EXPORT CalculateXKMSKEK(unsigned char * input, int inputLen, unsigned char * output, int maxOutputLen) {

    unsigned char keyVal[] = {XKMSKeyEncryption};
    unsigned char shaOutput[22];    // SHA1 has 20 bytes of output

    // Clean the input
    safeBuffer sb;
    int l = SASLCleanXKMSPassPhrase(input, inputLen, sb);

    // Need to iterate through until we have enough data
    int bytesDone = 0, bytesToDo;;
    shaOutput[0] = keyVal[0];
    int keyLen = 1;
    while (bytesDone < maxOutputLen) {
        XSECCryptoKeyHMAC * k = XSECPlatformUtils::g_cryptoProvider->keyHMAC();
        k->setKey(shaOutput, keyLen);

        XSECCryptoHash *h = XSECPlatformUtils::g_cryptoProvider->HMAC(XSECCryptoHash::HASH_SHA1);
        Janitor<XSECCryptoHash> j_h(h);

        h->setKey(k);
        delete(k);

        // Now hash next round of data
        h->hash((unsigned char *) sb.rawBuffer(), l);
        keyLen = h->finish(shaOutput, 22);

        // Copy into the output buffer
        bytesToDo = maxOutputLen - bytesDone;
        bytesToDo = bytesToDo > 20 ? 20 : bytesToDo;
        memcpy(&output[bytesDone], shaOutput, bytesToDo);
        bytesDone += bytesToDo;

        // Set up for next key
        shaOutput[0] ^= keyVal[0];
        keyLen = 20;

        j_h.release();
        delete h;
    }

    return bytesDone;

}

#endif

// --------------------------------------------------------------------------------
//           Some Base64 helpers
// --------------------------------------------------------------------------------

XMLCh XSEC_EXPORT * EncodeToBase64XMLCh(unsigned char * input, int inputLen) {

    XSECCryptoBase64 * b64 = XSECPlatformUtils::g_cryptoProvider->base64();
    Janitor<XSECCryptoBase64> j_b64(b64);
    unsigned char * output;
    int outputLen = ((4 * inputLen) / 3) + 5;
    XSECnew(output, unsigned char[outputLen]);
    ArrayJanitor<unsigned char> j_output(output);

    b64->encodeInit();
    int j = b64->encode(input, inputLen, output, outputLen - 1);
    j += b64->encodeFinish(&output[j], outputLen - j - 1);

    // Strip any trailing \n\r
    while (j > 0 && (output[j-1] == '\n' || output[j-1] == '\r'))
        j--;

    // Now transcode and get out of here
    output[j] = '\0';
    return XMLString::transcode((char *) output);

}

unsigned int XSEC_EXPORT DecodeFromBase64XMLCh(const XMLCh * input, unsigned char * output, int maxOutputLen) {

    XSECCryptoBase64 * b64 = XSECPlatformUtils::g_cryptoProvider->base64();
    Janitor<XSECCryptoBase64> j_b64(b64);

    XSECAutoPtrChar tinput(input);

    b64->decodeInit();
    unsigned int j = b64->decode((unsigned char *) tinput.get(), (unsigned int) strlen(tinput.get()), output, maxOutputLen - 1);
    j += b64->decodeFinish(&output[j], maxOutputLen - j - 1);

    return j;
}

unsigned int XSEC_EXPORT DecodeFromBase64(const char * input, unsigned char * output, int maxOutputLen) {

    XSECCryptoBase64 * b64 = XSECPlatformUtils::g_cryptoProvider->base64();
    Janitor<XSECCryptoBase64> j_b64(b64);

    b64->decodeInit();
    unsigned int j = b64->decode((unsigned char *) input, (unsigned int) strlen(input), output, maxOutputLen - 1);
    j += b64->decodeFinish(&output[j], maxOutputLen - j - 1);

    return j;
}


// --------------------------------------------------------------------------------
//           Some stuff to help with wierd signatures
// --------------------------------------------------------------------------------

const unsigned char ASNDSAProlog[] = {0x30, 0x2c, 0x02, 0x14};
const unsigned char ASNDSAMiddle[] = {0x02, 0x14};

bool ASN2DSASig(const unsigned char * input, unsigned char * r, unsigned char * s) {

    if (memcmp(ASNDSAProlog, input, 4) != 0 ||
        memcmp(ASNDSAMiddle, &input[24], 2) != 0)

        return false;

    memcpy(r, &input[4], 20);
    memcpy(s, &input[26], 20);

    return true;

}


// --------------------------------------------------------------------------------
//           Calculate correct OIDs for an RSA sig
// --------------------------------------------------------------------------------

/* As per RSA's PKCS #1 v 2.1, Section 9.2 Note 1, the DER encodings for
 * the has types are as follows:
 *
 * MD2: (0x)30 20 30 0c 06 08 2a 86 48 86 f7 0d 02 02 05 00 04 10 || H.
 * MD5: (0x)30 20 30 0c 06 08 2a 86 48 86 f7 0d 02 05 05 00 04 10 || H.
 * SHA-1: (0x)30 21 30 09 06 05 2b 0e 03 02 1a 05 00 04 14 || H.
 * SHA-256: (0x)30 31 30 0d 06 09 60 86 48 01 65 03 04 02 01 05 00 04 20 || H.
 * SHA-384: (0x)30 41 30 0d 06 09 60 86 48 01 65 03 04 02 02 05 00 04 30 || H.
 * SHA-512: (0x)30 51 30 0d 06 09 60 86 48 01 65 03 04 02 03 05 00 04 40 || H.
 *
 * More recently the following has been provided for SHA-224
 *
 * SHA-224: 30 2d 30 0d 06 09 60 86 48 01 65 03 04 02 04 05 00 04 1c
 *
 */

int MD5OIDLen = 18;
unsigned char MD5OID[] = {
    0x30, 0x20, 0x30, 0x0c, 0x06, 0x08, 0x2a, 0x86,
    0x48, 0x86, 0xf7, 0x0d, 0x02, 0x05, 0x05, 0x00,
    0x04, 0x10
};


int sha1OIDLen = 15;
unsigned char sha1OID[] = {
    0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2B, 0x0E,
    0x03, 0x02, 0x1A, 0x05, 0x00, 0x04, 0x14
};

int sha224OIDLen = 19;
unsigned char sha224OID[] = {
    0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05,
    0x00, 0x04, 0x1c
};

int sha256OIDLen = 19;
unsigned char sha256OID[] = {
    0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
    0x00, 0x04, 0x20
};

int sha384OIDLen = 19;
unsigned char sha384OID[] = {
    0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
    0x00, 0x04, 0x30
};

int sha512OIDLen = 19;
unsigned char sha512OID[] = {
    0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
    0x00, 0x04, 0x40
};


unsigned char* getRSASigOID(XSECCryptoHash::HashType type, int& oidLen) {

    switch (type) {

    case (XSECCryptoHash::HASH_MD5):
        oidLen = MD5OIDLen;
        return MD5OID;
    case (XSECCryptoHash::HASH_SHA1):
        oidLen = sha1OIDLen;
        return sha1OID;
    case (XSECCryptoHash::HASH_SHA224):
        oidLen = sha224OIDLen;
        return sha224OID;
    case (XSECCryptoHash::HASH_SHA256):
        oidLen = sha256OIDLen;
        return sha256OID;
    case (XSECCryptoHash::HASH_SHA384):
        oidLen = sha384OIDLen;
        return sha384OID;
    case (XSECCryptoHash::HASH_SHA512):
        oidLen = sha512OIDLen;
        return sha512OID;
    default:
        oidLen = 0;
        return NULL;

    }
}

XSECCryptoHash* XSECCryptoProvider::hash(const XMLCh* uri) const {

    return hash(XSECAlgorithmSupport::getHashType(uri));
}

XSECCryptoHash* XSECCryptoProvider::HMAC(const XMLCh* uri) const {

    return HMAC(XSECAlgorithmSupport::getHashType(uri));
}