You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@santuario.apache.org by sc...@apache.org on 2011/06/23 05:04:13 UTC
svn commit: r1138721 -
/santuario/xml-security-cpp/trunk/xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.cpp
Author: scantor
Date: Thu Jun 23 03:04:13 2011
New Revision: 1138721
URL: http://svn.apache.org/viewvc?rev=1138721&view=rev
Log:
SANTUARIO-280: inline OAEP functions from OpenSSL to handle SHA-2
Modified:
santuario/xml-security-cpp/trunk/xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.cpp
Modified: santuario/xml-security-cpp/trunk/xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.cpp
URL: http://svn.apache.org/viewvc/santuario/xml-security-cpp/trunk/xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.cpp?rev=1138721&r1=1138720&r2=1138721&view=diff
==============================================================================
--- santuario/xml-security-cpp/trunk/xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.cpp (original)
+++ santuario/xml-security-cpp/trunk/xsec/enc/OpenSSL/OpenSSLCryptoKeyRSA.cpp Thu Jun 23 03:04:13 2011
@@ -37,7 +37,10 @@
#include <xsec/enc/XSECCryptoUtils.hpp>
#include <xsec/framework/XSECError.hpp>
+#include <openssl/err.h>
+#include <openssl/rand.h>
#include <openssl/rsa.h>
+#include <openssl/sha.h>
#include <xercesc/util/Janitor.hpp>
@@ -45,6 +48,164 @@ XSEC_USING_XERCES(ArrayJanitor);
#include <memory.h>
+namespace {
+
+ // This code is modified from OpenSSL to implement SHA-2 hashing with OAEP.
+ // The MGF code is limited to SHA-1 in accordance with the XML Encryption spec.
+ static int MGF1(unsigned char *mask, long len, const unsigned char *seed, long seedlen)
+ {
+ return PKCS1_MGF1(mask, len, seed, seedlen, EVP_sha1());
+ }
+
+ int RSA_padding_add_PKCS1_OAEP(unsigned char *to, int tlen,
+ const unsigned char *from, int flen,
+ const unsigned char *param, int plen,
+ const EVP_MD* digest)
+ {
+ int i, digestlen = EVP_MD_size(digest), emlen = tlen - 1;
+ unsigned char *db, *seed;
+ unsigned char *dbmask, seedmask[EVP_MAX_MD_SIZE]; // accomodate largest hash size
+
+ if (flen > emlen - 2 * digestlen - 1)
+ {
+ RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP,
+ RSA_R_DATA_TOO_LARGE_FOR_KEY_SIZE);
+ return 0;
+ }
+
+ if (emlen < 2 * digestlen + 1)
+ {
+ RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, RSA_R_KEY_SIZE_TOO_SMALL);
+ return 0;
+ }
+
+ to[0] = 0;
+ seed = to + 1;
+ db = to + digestlen + 1;
+
+ EVP_Digest((void *)param, plen, db, NULL, digest, NULL);
+ memset(db + digestlen, 0,
+ emlen - flen - 2 * digestlen - 1);
+ db[emlen - flen - digestlen - 1] = 0x01;
+ memcpy(db + emlen - flen - digestlen, from, (unsigned int) flen);
+ if (RAND_bytes(seed, digestlen) <= 0)
+ return 0;
+
+ dbmask = (unsigned char*) OPENSSL_malloc(emlen - digestlen);
+ if (dbmask == NULL)
+ {
+ RSAerr(RSA_F_RSA_PADDING_ADD_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
+ return 0;
+ }
+
+ if (MGF1(dbmask, emlen - digestlen, seed, digestlen) < 0)
+ return 0;
+ for (i = 0; i < emlen - digestlen; i++)
+ db[i] ^= dbmask[i];
+
+ if (MGF1(seedmask, digestlen, db, emlen - digestlen) < 0)
+ return 0;
+ for (i = 0; i < digestlen; i++)
+ seed[i] ^= seedmask[i];
+
+ OPENSSL_free(dbmask);
+ return 1;
+ }
+
+ int RSA_padding_check_PKCS1_OAEP(unsigned char *to, int tlen,
+ const unsigned char *from, int flen, int num,
+ const unsigned char *param, int plen,
+ const EVP_MD* digest)
+ {
+ int i, digestlen = EVP_MD_size(digest), dblen, mlen = -1;
+ const unsigned char *maskeddb;
+ int lzero;
+ unsigned char *db = NULL, seed[EVP_MAX_MD_SIZE], phash[EVP_MAX_MD_SIZE];
+ unsigned char *padded_from;
+ int bad = 0;
+
+ if (--num < 2 * digestlen + 1)
+ /* 'num' is the length of the modulus, i.e. does not depend on the
+ * particular ciphertext. */
+ goto decoding_err;
+
+ lzero = num - flen;
+ if (lzero < 0)
+ {
+ /* signalling this error immediately after detection might allow
+ * for side-channel attacks (e.g. timing if 'plen' is huge
+ * -- cf. James H. Manger, "A Chosen Ciphertext Attack on RSA Optimal
+ * Asymmetric Encryption Padding (OAEP) [...]", CRYPTO 2001),
+ * so we use a 'bad' flag */
+ bad = 1;
+ lzero = 0;
+ flen = num; /* don't overflow the memcpy to padded_from */
+ }
+
+ dblen = num - digestlen;
+ db = (unsigned char*) OPENSSL_malloc(dblen + num);
+ if (db == NULL)
+ {
+ RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP, ERR_R_MALLOC_FAILURE);
+ return -1;
+ }
+
+ /* Always do this zero-padding copy (even when lzero == 0)
+ * to avoid leaking timing info about the value of lzero. */
+ padded_from = db + dblen;
+ memset(padded_from, 0, lzero);
+ memcpy(padded_from + lzero, from, flen);
+
+ maskeddb = padded_from + digestlen;
+
+ if (MGF1(seed, digestlen, maskeddb, dblen))
+ return -1;
+ for (i = 0; i < digestlen; i++)
+ seed[i] ^= padded_from[i];
+
+ if (MGF1(db, dblen, seed, digestlen))
+ return -1;
+ for (i = 0; i < dblen; i++)
+ db[i] ^= maskeddb[i];
+
+ EVP_Digest((void *)param, plen, phash, NULL, digest, NULL);
+
+ if (memcmp(db, phash, digestlen) != 0 || bad)
+ goto decoding_err;
+ else
+ {
+ for (i = digestlen; i < dblen; i++)
+ if (db[i] != 0x00)
+ break;
+ if (i == dblen || db[i] != 0x01)
+ goto decoding_err;
+ else
+ {
+ /* everything looks OK */
+
+ mlen = dblen - ++i;
+ if (tlen < mlen)
+ {
+ RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP, RSA_R_DATA_TOO_LARGE);
+ mlen = -1;
+ }
+ else
+ memcpy(to, db + i, mlen);
+ }
+ }
+ OPENSSL_free(db);
+ return mlen;
+
+ decoding_err:
+ /* to avoid chosen ciphertext attacks, the error message should not reveal
+ * which kind of decoding error happened */
+ RSAerr(RSA_F_RSA_PADDING_CHECK_PKCS1_OAEP, RSA_R_OAEP_DECODING_ERROR);
+ if (db != NULL) OPENSSL_free(db);
+ return -1;
+ }
+
+};
+
OpenSSLCryptoKeyRSA::OpenSSLCryptoKeyRSA() :
mp_rsaKey(NULL),
mp_oaepParams(NULL),
@@ -445,6 +606,29 @@ unsigned int OpenSSLCryptoKeyRSA::privat
int num = RSA_size(mp_rsaKey);
XSECnew(tBuf, unsigned char[inLength]);
ArrayJanitor<unsigned char> j_tBuf(tBuf);
+ const EVP_MD* evp_md = NULL;
+ switch (hm) {
+ case HASH_SHA1:
+ evp_md = EVP_get_digestbyname("SHA1");
+ break;
+ case HASH_SHA224:
+ evp_md = EVP_get_digestbyname("SHA224");
+ break;
+ case HASH_SHA256:
+ evp_md = EVP_get_digestbyname("SHA256");
+ break;
+ case HASH_SHA384:
+ evp_md = EVP_get_digestbyname("SHA384");
+ break;
+ case HASH_SHA512:
+ evp_md = EVP_get_digestbyname("SHA512");
+ break;
+ }
+
+ if (evp_md == NULL) {
+ throw XSECCryptoException(XSECCryptoException::MDError,
+ "OpenSSL:RSA - OAEP digest algorithm not supported by this version of OpenSSL");
+ }
decryptSize = RSA_private_decrypt(inLength,
#if defined(XSEC_OPENSSL_CONST_BUFFERS)
@@ -473,7 +657,8 @@ unsigned int OpenSSLCryptoKeyRSA::privat
decryptSize,
num,
mp_oaepParams,
- m_oaepParamsLen);
+ m_oaepParamsLen,
+ evp_md);
if (decryptSize < 0) {
@@ -563,6 +748,30 @@ unsigned int OpenSSLCryptoKeyRSA::public
"OpenSSL:RSA publicKeyEncrypt - Not enough space in cipherBuf");
}
+ const EVP_MD* evp_md = NULL;
+ switch (hm) {
+ case HASH_SHA1:
+ evp_md = EVP_get_digestbyname("SHA1");
+ break;
+ case HASH_SHA224:
+ evp_md = EVP_get_digestbyname("SHA224");
+ break;
+ case HASH_SHA256:
+ evp_md = EVP_get_digestbyname("SHA256");
+ break;
+ case HASH_SHA384:
+ evp_md = EVP_get_digestbyname("SHA384");
+ break;
+ case HASH_SHA512:
+ evp_md = EVP_get_digestbyname("SHA512");
+ break;
+ }
+
+ if (evp_md == NULL) {
+ throw XSECCryptoException(XSECCryptoException::MDError,
+ "OpenSSL:RSA - OAEP digest algorithm not supported by this version of OpenSSL");
+ }
+
XSECnew(tBuf, unsigned char[num]);
ArrayJanitor<unsigned char> j_tBuf(tBuf);
@@ -570,14 +779,15 @@ unsigned int OpenSSLCryptoKeyRSA::public
encryptSize = RSA_padding_add_PKCS1_OAEP(tBuf,
num,
-#if defined(XSEC_OPENSSL_CONST_BUFFERS)
+//#if defined(XSEC_OPENSSL_CONST_BUFFERS)
inBuf,
-#else
- (unsigned char *) inBuf,
-#endif
+//#else
+// (unsigned char *) inBuf,
+//#endif
inLength,
mp_oaepParams,
- m_oaepParamsLen);
+ m_oaepParamsLen,
+ evp_md);
if (encryptSize <= 0) {