xsec/enc/XSECCryptoUtils.cpp (330 lines of code) (raw):
/**
* 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));
}