int UtlCryptoKeyRsa::sign(const unsigned char* pSrc,
int srcLen,
unsigned char* pDest,
int* pDestLen) const
{
if (!pSrc || !srcLen || !pDest || !pDestLen ||
*pDestLen < getMaxSignatureSize(srcLen))
{
if (pDestLen)
*pDestLen = 0;
return 0;
}
*pDestLen = 0;
// First, compute the Message Digest (MD) of the source data
int mdLen = EVP_MAX_MD_SIZE;
unsigned char md[EVP_MAX_MD_SIZE];
if (computeDigest(pSrc, srcLen, &md[0], &mdLen) == 0)
return 0;
// Next, sign the Message Digest & return that
if (!RSA_sign(getDigestAlgType(), &md[0], mdLen,
pDest, (unsigned*)pDestLen, mpRsa))
{
osPrintf("*****RSA_sign failed");
return 0;
}
setLastError(0);
return *pDestLen;
}
int main(int argc, char *argv[])
{
unsigned char* signature;
unsigned int slen;
RSA *private_key = NULL;
BIO *priv_bio;
unsigned char buffer[SIG_LEN];
if (argc < 3)
{
printf("Usage: %s image_file signed_file\n", argv[0]);
exit(-1);
}
raw_file = fopen(argv[1], "r");
new_file = fopen(argv[2], "w");
if (!raw_file || !new_file)
{
fprintf(stderr, "Open file error\n");
exit(-1);
}
priv_bio = BIO_new_mem_buf(priv_key, -1);
if(priv_bio == NULL)
{
fprintf(stderr, "priv_bio is null\n");
exit(-1);
}
private_key = PEM_read_bio_RSAPrivateKey(priv_bio, NULL, NULL, NULL);
if(private_key == NULL)
{
fprintf(stderr, "private_key is null\n");
exit(-1);
}
signature = (unsigned char*) malloc(RSA_size(private_key));
if (calc_sha256() != 0)
{
fprintf(stderr, "calc_sha256 error\n");
exit(-1);
}
if(RSA_sign(NID_sha256, (unsigned char*) calc_hash, strlen(calc_hash),
signature, &slen, private_key) != 1)
{
fprintf(stderr, "RSA_sign error\n");
}
fwrite(signature, SIG_LEN, 1, new_file);
int bytesRead = 0;
while((bytesRead = fread(buffer, 1, SIG_LEN, raw_file)))
{
fwrite(buffer, bytesRead, 1, new_file);
}
/* free resouces */
return 0;
}
int
rsa_sign(char *path, struct rsa_key *rsa, unsigned char **sigret, unsigned int *siglen)
{
char errbuf[1024];
int max_len = 0, ret;
char sha256[SHA256_DIGEST_LENGTH * 2 +1];
if (access(rsa->path, R_OK) == -1) {
pkg_emit_errno("access", rsa->path);
return (EPKG_FATAL);
}
if (rsa->key == NULL && _load_rsa_private_key(rsa) != EPKG_OK) {
pkg_emit_error("can't load key from %s", rsa->path);
return (EPKG_FATAL);
}
max_len = RSA_size(rsa->key);
*sigret = calloc(1, max_len + 1);
sha256_file(path, sha256);
ret = RSA_sign(NID_sha1, sha256, sizeof(sha256), *sigret, siglen, rsa->key);
if (ret == 0) {
/* XXX pass back RSA errors correctly */
pkg_emit_error("%s: %s", rsa->path,
ERR_error_string(ERR_get_error(), errbuf));
return (EPKG_FATAL);
}
return (EPKG_OK);
}
/*
* Maybe the missing function from libcrypto
*
* I think now, maybe it's a bad idea to name it has it should have be
* named in libcrypto
*/
ssh_string RSA_do_sign(const unsigned char *payload, int len, RSA *privkey) {
ssh_string sign = NULL;
unsigned char *buffer = NULL;
unsigned int size;
buffer = malloc(RSA_size(privkey));
if (buffer == NULL) {
return NULL;
}
if (RSA_sign(NID_sha1, payload, len, buffer, &size, privkey) == 0) {
SAFE_FREE(buffer);
return NULL;
}
sign = ssh_string_new(size);
if (sign == NULL) {
SAFE_FREE(buffer);
return NULL;
}
ssh_string_fill(sign, buffer, size);
SAFE_FREE(buffer);
return sign;
}
bool CreateRSASignature(std::string privateKey, void* data, size_t dataSize, std::string& signature)
{
// privateKey has to be reformatted with -----RSA PRIVATE KEY----- header/footer and newlines after every 64 chars
// before calling this function
BIO* privKeyBuff = BIO_new_mem_buf((void*)privateKey.c_str(), privateKey.length());
if (!privKeyBuff)
return false;
RSA* rsa = PEM_read_bio_RSAPrivateKey(privKeyBuff, 0, 0, 0);
if (!rsa)
return false;
unsigned char hash[SHA256_DIGEST_LENGTH];
SHA256_CTX sha;
SHA256_Init(&sha);
SHA256_Update(&sha, data, dataSize);
SHA256_Final(hash, &sha);
void* sigret = malloc(RSA_size(rsa));
unsigned int siglen = 0;
int retVal = RSA_sign(NID_sha256, (unsigned char*)hash, SHA256_DIGEST_LENGTH, (unsigned char*)sigret, &siglen, rsa);
RSA_free(rsa);
BIO_free_all(privKeyBuff);
if (retVal != 1)
return false;
signature = Utils::String::Base64Encode((unsigned char*)sigret, siglen);
return true;
}
static int
pkey_rsa_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
const unsigned char *tbs, size_t tbslen)
{
int ret;
RSA_PKEY_CTX *rctx = ctx->data;
RSA *rsa = ctx->pkey->pkey.rsa;
if (rctx->md) {
if (tbslen != (size_t)EVP_MD_size(rctx->md)) {
RSAerr(RSA_F_PKEY_RSA_SIGN,
RSA_R_INVALID_DIGEST_LENGTH);
return -1;
}
if (EVP_MD_type(rctx->md) == NID_mdc2) {
unsigned int sltmp;
if (rctx->pad_mode != RSA_PKCS1_PADDING)
return -1;
ret = RSA_sign_ASN1_OCTET_STRING(NID_mdc2, tbs, tbslen,
sig, &sltmp, rsa);
if (ret <= 0)
return ret;
ret = sltmp;
} else if (rctx->pad_mode == RSA_X931_PADDING) {
if (!setup_tbuf(rctx, ctx))
return -1;
memcpy(rctx->tbuf, tbs, tbslen);
rctx->tbuf[tbslen] =
RSA_X931_hash_id(EVP_MD_type(rctx->md));
ret = RSA_private_encrypt(tbslen + 1, rctx->tbuf, sig,
rsa, RSA_X931_PADDING);
} else if (rctx->pad_mode == RSA_PKCS1_PADDING) {
unsigned int sltmp;
ret = RSA_sign(EVP_MD_type(rctx->md), tbs, tbslen, sig,
&sltmp, rsa);
if (ret <= 0)
return ret;
ret = sltmp;
} else if (rctx->pad_mode == RSA_PKCS1_PSS_PADDING) {
if (!setup_tbuf(rctx, ctx))
return -1;
if (!RSA_padding_add_PKCS1_PSS_mgf1(rsa, rctx->tbuf,
tbs, rctx->md, rctx->mgf1md, rctx->saltlen))
return -1;
ret = RSA_private_encrypt(RSA_size(rsa), rctx->tbuf,
sig, rsa, RSA_NO_PADDING);
} else
return -1;
} else
ret = RSA_private_encrypt(tbslen, tbs, sig, ctx->pkey->pkey.rsa,
rctx->pad_mode);
if (ret < 0)
return ret;
*siglen = ret;
return 1;
}
ldns_rdf *
ldns_sign_public_rsasha1(ldns_buffer *to_sign, RSA *key)
{
unsigned char *sha1_hash;
unsigned int siglen;
ldns_rdf *sigdata_rdf;
ldns_buffer *b64sig;
int result;
siglen = 0;
b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN);
if (!b64sig) {
return NULL;
}
sha1_hash = SHA1((unsigned char*)ldns_buffer_begin(to_sign),
ldns_buffer_position(to_sign), NULL);
if (!sha1_hash) {
ldns_buffer_free(b64sig);
return NULL;
}
result = RSA_sign(NID_sha1, sha1_hash, SHA_DIGEST_LENGTH,
(unsigned char*)ldns_buffer_begin(b64sig),
&siglen, key);
if (result != 1) {
ldns_buffer_free(b64sig);
return NULL;
}
sigdata_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, siglen,
ldns_buffer_begin(b64sig));
ldns_buffer_free(b64sig); /* can't free this buffer ?? */
return sigdata_rdf;
}
/**
* @brief Sign a message with provided RSA key.
*
* Hash msg (SHA1) and encrypt the resulting digest. The buffer supplied to hold
* the signature must be at least RSA_size(keypair) bytes long.
*
* @param msg Data to sign.
* @param msg_len Size of data to sign.
* @param sigbuf Buffer to hold created signature.
* @param sigbuflen Space available for signature.
*
* @return Size of signature on success, 0 on error.
*/
uint32_t sign(RSA *keypair, char *msg, size_t msg_len, char *sigbuf, int sigbuflen) {
if (sigbuflen < RSA_size(keypair)) {
ERROR("ERROR: Could not sign message because sigbuf is too small");
return 0;
}
/* first hash msg */
unsigned char *digest = hash(msg, msg_len);
if (digest == NULL) {
ERROR("ERROR: Unable to hash message");
return 0;
}
/* now sign the hash */
uint32_t siglen;
if (RSA_sign(NID_sha1, digest, SHA_DIGEST_LENGTH, (unsigned char*)sigbuf, &siglen, keypair) != 1) {
char *err = (char *)malloc(130); //FIXME?
ERR_load_crypto_strings();
ERR_error_string(ERR_get_error(), err);
ERRORF("Error signing message: %s", err);
free(err);
return 0;
}
free(digest);
return siglen;
}
int
sign(char* private_key_path, unsigned char *msg, int msg_len,
unsigned char *sig, unsigned int *sig_len)
{
//Load private key
FILE *fp = fopen(private_key_path, "r");
if(!fp) {
DEBUGMSG(ERROR, "Could not find private key\n");
return 0;
}
RSA *rsa = (RSA *) PEM_read_RSAPrivateKey(fp,NULL,NULL,NULL);
fclose(fp);
if(!rsa) return 0;
unsigned char md[SHA256_DIGEST_LENGTH];
sha(msg, msg_len, md);
//Compute signatur
int err = RSA_sign(NID_sha256, md, SHA256_DIGEST_LENGTH, (unsigned char*)sig, (unsigned int*)sig_len, rsa);
if(!err){
printf("Error: %ul\n", (unsigned int)ERR_get_error());
}
RSA_free(rsa);
return err;
}
bool SecurityHelper::signDataObject(DataObjectRef& dObj, RSA *key)
{
unsigned char *signature;
if (!key || !dObj)
return false;
unsigned int siglen = RSA_size(key);
signature = (unsigned char *)malloc(siglen);
if (!signature)
return false;
printf("signing data object, siglen=%u\n", siglen);
memset(signature, 0, siglen);
if (RSA_sign(NID_sha1, dObj->getId(), sizeof(DataObjectId_t), signature, &siglen, key) != 1) {
free(signature);
return false;
}
dObj->setSignature(getManager()->getKernel()->getThisNode()->getIdStr(), signature, siglen);
// Assume that our own signature is valid
dObj->setSignatureStatus(DataObject::SIGNATURE_VALID);
// Do not free the allocated signature as it is now owned by the data object...
return true;
}
ldns_rdf *
ldns_sign_public_rsamd5(ldns_buffer *to_sign, RSA *key)
{
unsigned char *md5_hash;
unsigned int siglen;
ldns_rdf *sigdata_rdf;
ldns_buffer *b64sig;
b64sig = ldns_buffer_new(LDNS_MAX_PACKETLEN);
if (!b64sig) {
return NULL;
}
md5_hash = MD5((unsigned char*)ldns_buffer_begin(to_sign),
ldns_buffer_position(to_sign), NULL);
if (!md5_hash) {
ldns_buffer_free(b64sig);
return NULL;
}
RSA_sign(NID_md5, md5_hash, MD5_DIGEST_LENGTH,
(unsigned char*)ldns_buffer_begin(b64sig),
&siglen, key);
sigdata_rdf = ldns_rdf_new_frm_data(LDNS_RDF_TYPE_B64, siglen,
ldns_buffer_begin(b64sig));
ldns_buffer_free(b64sig);
return sigdata_rdf;
}
static int __ast_sign_bin(struct ast_key *key, const char *msg, int msglen, unsigned char *dsig)
{
unsigned char digest[20];
unsigned int siglen = 128;
int res;
if (key->ktype != AST_KEY_PRIVATE) {
ast_log(LOG_WARNING, "Cannot sign with a public key\n");
return -1;
}
/* Calculate digest of message */
SHA1((unsigned char *)msg, msglen, digest);
/* Verify signature */
res = RSA_sign(NID_sha1, digest, sizeof(digest), dsig, &siglen, key->rsa);
if (!res) {
ast_log(LOG_WARNING, "RSA Signature (key %s) failed\n", key->name);
return -1;
}
if (siglen != 128) {
ast_log(LOG_WARNING, "Unexpected signature length %d, expecting %d\n", (int)siglen, (int)128);
return -1;
}
return 0;
}
// private_key_operation: perform a private key operation
kssl_error_code private_key_operation(pk_list list, // Private key array from new_pk_list
int key_id, // ID of key in pk_list from find_private_key
int opcode, // Opcode from a KSSL message indicating the operation
int length, // Length of data in message
BYTE *message, // Bytes to perform operation on
BYTE *out, // Buffer into which operation output is written
unsigned int *size) { // Size of returned data written here
int rc = KSSL_ERROR_NONE;
// Currently, we only support decrypt or sign here
if (opcode == KSSL_OP_RSA_DECRYPT) {
int s = RSA_private_decrypt(length, message, out, list->privates[key_id].key,
RSA_PKCS1_PADDING);
if (s != -1) {
*size = (unsigned int)s;
} else {
rc = KSSL_ERROR_CRYPTO_FAILED;
ERR_clear_error();
}
} else {
if (RSA_sign(opcode_to_digest_nid(opcode), message, length, out, size,
list->privates[key_id].key) != 1) {
rc = KSSL_ERROR_CRYPTO_FAILED;
}
}
return rc;
}
int s2n_rsa_sign(struct s2n_rsa_private_key *key, struct s2n_hash_state *digest, struct s2n_blob *signature)
{
uint8_t digest_out[MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH];
int type, digest_length;
if (digest->alg == S2N_HASH_MD5_SHA1) {
type = NID_md5_sha1;
digest_length = MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH;
} else if (digest->alg == S2N_HASH_SHA1) {
type = NID_sha1;
digest_length = SHA_DIGEST_LENGTH;
} else {
S2N_ERROR(S2N_ERR_HASH_INVALID_ALGORITHM);
}
GUARD(s2n_hash_digest(digest, digest_out, digest_length));
unsigned int signature_size = signature->size;
if (RSA_sign(type, digest_out, digest_length, signature->data, &signature_size, key->rsa) == 0) {
S2N_ERROR(S2N_ERR_SIGN);
}
if (signature_size > signature->size) {
S2N_ERROR(S2N_ERR_SIZE_MISMATCH);
}
signature->size = signature_size;
return 0;
}
int
_libssh2_rsa_sha1_sign(LIBSSH2_SESSION * session,
libssh2_rsa_ctx * rsactx,
const unsigned char *hash,
unsigned long hash_len,
unsigned char **signature, unsigned long *signature_len)
{
int ret;
unsigned char *sig;
unsigned int sig_len;
sig_len = RSA_size(rsactx);
sig = LIBSSH2_ALLOC(session, sig_len);
if (!sig) {
return -1;
}
ret = RSA_sign(NID_sha1, hash, hash_len, sig, &sig_len, rsactx);
if (!ret) {
LIBSSH2_FREE(session, sig);
return -1;
}
*signature = sig;
*signature_len = sig_len;
return 0;
}
SEXP PKI_sign_RSA(SEXP what, SEXP sMD, SEXP sKey) {
SEXP res;
int md = asInteger(sMD);
EVP_PKEY *key;
RSA *rsa;
unsigned int siglen = sizeof(buf);
if (md != PKI_MD5 && md != PKI_SHA1)
Rf_error("unsupported hash type");
if (TYPEOF(what) != RAWSXP ||
(md == PKI_MD5 && LENGTH(what) != MD5_DIGEST_LENGTH) ||
(md == PKI_SHA1 && LENGTH(what) != SHA_DIGEST_LENGTH))
Rf_error("invalid hash");
if (!inherits(sKey, "private.key"))
Rf_error("key must be RSA private key");
key = (EVP_PKEY*) R_ExternalPtrAddr(sKey);
if (!key)
Rf_error("NULL key");
if (EVP_PKEY_type(key->type) != EVP_PKEY_RSA)
Rf_error("key must be RSA private key");
rsa = EVP_PKEY_get1_RSA(key);
if (!rsa)
Rf_error("%s", ERR_error_string(ERR_get_error(), NULL));
if (RSA_sign((md == PKI_MD5) ? NID_md5 : NID_sha1,
(const unsigned char*) RAW(what), LENGTH(what),
(unsigned char *) buf, &siglen, rsa) != 1)
Rf_error("%s", ERR_error_string(ERR_get_error(), NULL));
res = allocVector(RAWSXP, siglen);
memcpy(RAW(res), buf, siglen);
return res;
}
static int sign_stub(struct expbuf_t *buf)
{
unsigned char *m, sigret[4096];
size_t type, m_len, key_index;
RSA *rsa;
unsigned siglen = 0;
int ret;
if (expbuf_shift_num(buf, &type) != 0 || (m = expbuf_shift_bytes(buf, &m_len)) == NULL ||
expbuf_shift_num(buf, &key_index) != 0) {
errno = 0;
warnf("%s: failed to parse request", __FUNCTION__);
return -1;
}
if ((rsa = daemon_get_rsa(key_index)) == NULL) {
errno = 0;
warnf("%s: invalid key index:%zu", __FUNCTION__, key_index);
return -1;
}
ret = RSA_sign((int)type, m, (unsigned)m_len, sigret, &siglen, rsa);
expbuf_dispose(buf);
expbuf_push_num(buf, ret);
expbuf_push_bytes(buf, sigret, ret == 1 ? siglen : 0);
return 0;
}
/**
* Signs the digest with provided RSA private key.
*
* @param digestMethod digest method (e.g NID_sha1 for SHA1, see openssl/obj_mac.h).
* @param digest digest value, this value is signed with the private RSA key.
* @return returns signature.
* @throws IOException
*/
std::vector<unsigned char> digidoc::RSACrypt::sign(const Signer::Digest& digest) throw(IOException)
{
// Calculate memory needed for signature.
unsigned int blockSize = RSA_size(privateKey);
unsigned int neededSize = blockSize;
if(digest.length > blockSize)
{
if(digest.length % blockSize == 0)
neededSize = digest.length;
else
neededSize = ((digest.length / blockSize) + 1) * blockSize;
}
// Allocate memory for the signature.
std::vector<unsigned char> signature(neededSize, 0);
// Sign the digest with private RSA key.
unsigned int signatureLength = 0;
int result = RSA_sign(digest.type, digest.digest, digest.length, &signature[0], &signatureLength, privateKey);
// Check that signing was successful.
if(result != 1)
{
THROW_IOEXCEPTION("Failed to sign the digest: %s", ERR_reason_error_string(ERR_get_error()));
}
if(signatureLength != neededSize)
{
THROW_IOEXCEPTION("Failed to sign the digest.");
}
return signature;
}
extern "C" int32_t
CryptoNative_RsaSign(int32_t type, const uint8_t* m, int32_t mlen, uint8_t* sigret, int32_t* siglen, RSA* rsa)
{
if (siglen == nullptr)
{
assert(false);
return 0;
}
*siglen = 0;
if (HasNoPrivateKey(rsa))
{
ERR_PUT_error(ERR_LIB_RSA, RSA_F_RSA_SIGN, RSA_R_VALUE_MISSING, __FILE__, __LINE__);
return 0;
}
// Shared pointer to the metadata about the message digest algorithm
const EVP_MD* digest = EVP_get_digestbynid(type);
// If the digest itself isn't known then RSA_R_UNKNOWN_ALGORITHM_TYPE will get reported, but
// we have to check that the digest size matches what we expect.
if (digest != nullptr && mlen != EVP_MD_size(digest))
{
ERR_PUT_error(ERR_LIB_RSA, RSA_F_RSA_SIGN, RSA_R_INVALID_MESSAGE_LENGTH, __FILE__, __LINE__);
return 0;
}
unsigned int unsignedSigLen = 0;
int32_t ret = RSA_sign(type, m, UnsignedCast(mlen), sigret, &unsignedSigLen, rsa);
assert(unsignedSigLen <= INT32_MAX);
*siglen = static_cast<int32_t>(unsignedSigLen);
return ret;
}
Block
SecTpmMemory::signInTpm(const uint8_t *data, size_t dataLength,
const Name& keyName,
DigestAlgorithm digestAlgorithm)
{
if (digestAlgorithm != DIGEST_ALGORITHM_SHA256)
return ConstBufferPtr();
// Find the private key and sign.
PrivateKeyStore::iterator privateKey = privateKeyStore_.find(keyName.toUri());
if (privateKey == privateKeyStore_.end())
throw Error(string("MemoryPrivateKeyStorage: Cannot find private key ") + keyName.toUri());
uint8_t digest[SHA256_DIGEST_LENGTH];
SHA256_CTX sha256;
SHA256_Init(&sha256);
SHA256_Update(&sha256, data, dataLength);
SHA256_Final(digest, &sha256);
BufferPtr signatureBuffer = ptr_lib::make_shared<Buffer>();
signatureBuffer->resize(RSA_size(privateKey->second->getPrivateKey()));
unsigned int signatureBitsLength;
if (!RSA_sign(NID_sha256, digest, sizeof(digest),
signatureBuffer->buf(),
&signatureBitsLength,
privateKey->second->getPrivateKey()))
{
throw Error("Error in RSA_sign");
}
return Block(Tlv::SignatureValue, signatureBuffer);
}
int ssh_key_sign(ssh_key* key, const char* data, int length, unsigned char* sig) {
const EVP_MD* md;
EVP_MD_CTX md_ctx;
unsigned char digest[EVP_MAX_MD_SIZE];
unsigned int dlen, len;
/* Get SHA1 digest */
if ((md = EVP_get_digestbynid(NID_sha1)) == NULL)
return -1;
/* Digest data */
EVP_DigestInit(&md_ctx, md);
EVP_DigestUpdate(&md_ctx, data, length);
EVP_DigestFinal(&md_ctx, digest, &dlen);
/* Sign with key */
switch (key->type) {
case SSH_KEY_RSA:
if (RSA_sign(NID_sha1, digest, dlen, sig, &len, key->rsa) == 1)
return len;
case SSH_KEY_DSA: {
DSA_SIG* dsa_sig = DSA_do_sign(digest, dlen, key->dsa);
if (dsa_sig != NULL) {
/* Compute size of each half of signature */
int rlen = BN_num_bytes(dsa_sig->r);
int slen = BN_num_bytes(dsa_sig->s);
/* Ensure each number is within the required size */
if (rlen > DSA_SIG_NUMBER_SIZE || slen > DSA_SIG_NUMBER_SIZE)
return -1;
/* Init to all zeroes */
memset(sig, 0, DSA_SIG_SIZE);
/* Add R at the end of the first block of the signature */
BN_bn2bin(dsa_sig->r, sig + DSA_SIG_SIZE
- DSA_SIG_NUMBER_SIZE - rlen);
/* Add S at the end of the second block of the signature */
BN_bn2bin(dsa_sig->s, sig + DSA_SIG_SIZE - slen);
/* Done */
DSA_SIG_free(dsa_sig);
return DSA_SIG_SIZE;
}
}
}
return -1;
}
int rtp_pkt_sign(rtp_pkt_t *pkt, RSA *rsa) {
assert(pkt != NULL);
assert(rsa != NULL);
if (pkt->length + RSA_size(rsa) + 1 > RTP_PKT_SIZE)
return 0;
EVP_MD_CTX ctx;
EVP_DigestInit(&ctx, EVP_sha1());
EVP_DigestUpdate(&ctx, pkt->data + pkt->hlen, pkt->length);
unsigned char md[EVP_MAX_MD_SIZE];
unsigned int mdlen;
EVP_DigestFinal(&ctx, md, &mdlen);
int slen;
if (!RSA_sign(NID_sha1, md, mdlen,
pkt->data + pkt->hlen + pkt->length, &slen, rsa))
return 0;
pkt->plen = slen;
pkt->b.p = 1;
return 1;
}
/*
* ToDo: problems with RSA_PKCS1_OAEP_PADDING -> RSA_PKCS1_PSS_PADDING is
* needed (Version 0.9.9); RSA_PKCS1_OAEP_PADDING is just for encryption
*/
OpcUa_StatusCode OpcUa_P_OpenSSL_RSA_Private_Sign(
OpcUa_CryptoProvider* a_pProvider,
OpcUa_ByteString a_data,
OpcUa_Key* a_privateKey,
OpcUa_Int16 a_padding, /* e.g. RSA_PKCS1_PADDING */
OpcUa_ByteString* a_pSignature) /* output length >= key length */
{
EVP_PKEY* pSSLPrivateKey = OpcUa_Null;
const unsigned char* pData = OpcUa_Null;
int iErr = 0;
OpcUa_InitializeStatus(OpcUa_Module_P_OpenSSL, "RSA_Private_Sign");
/* unused parameters */
OpcUa_ReferenceParameter(a_pProvider);
OpcUa_ReferenceParameter(a_padding);
/* check parameters */
OpcUa_ReturnErrorIfArgumentNull(a_privateKey);
OpcUa_ReturnErrorIfArgumentNull(a_pSignature);
pData = a_privateKey->Key.Data;
OpcUa_ReturnErrorIfArgumentNull(pData);
OpcUa_ReturnErrorIfTrue((a_privateKey->Type != OpcUa_Crypto_KeyType_Rsa_Private), OpcUa_BadInvalidArgument);
/* convert private key and check key length against buffer length */
pSSLPrivateKey = d2i_PrivateKey(EVP_PKEY_RSA, OpcUa_Null, &pData, a_privateKey->Key.Length);
OpcUa_GotoErrorIfTrue((pSSLPrivateKey == OpcUa_Null), OpcUa_BadUnexpectedError);
OpcUa_GotoErrorIfTrue((a_pSignature->Length < RSA_size(pSSLPrivateKey->pkey.rsa)), OpcUa_BadInvalidArgument);
/* sign data */
iErr = RSA_sign(NID_sha1, a_data.Data, a_data.Length, a_pSignature->Data, (unsigned int*)&a_pSignature->Length, pSSLPrivateKey->pkey.rsa);
OpcUa_GotoErrorIfTrue((iErr != 1), OpcUa_BadUnexpectedError);
/* free internal key representation */
EVP_PKEY_free(pSSLPrivateKey);
OpcUa_ReturnStatusCode;
OpcUa_BeginErrorHandling;
if(OpcUa_IsEqual(OpcUa_BadUnexpectedError))
{
long lErr = ERR_get_error();
char* szErr = ERR_error_string(lErr, 0);
if(szErr != OpcUa_Null)
{
OpcUa_P_Trace("*** RSA_Private_Sign: ");
OpcUa_P_Trace(szErr);
OpcUa_P_Trace(" ***\n");
}
}
if(pSSLPrivateKey != OpcUa_Null)
{
EVP_PKEY_free(pSSLPrivateKey);
}
OpcUa_FinishErrorHandling;
}
static PARCSignature *
_SignDigest(PARCPublicKeySigner *signer, const PARCCryptoHash *digestToSign)
{
parcSecurity_AssertIsInitialized();
assertNotNull(signer, "Parameter must be non-null CCNxFileKeystore");
assertNotNull(digestToSign, "Buffer to sign must not be null");
// TODO: what is the best way to expose this?
PARCKeyStore *keyStore = signer->keyStore;
PARCBuffer *privateKeyBuffer = parcKeyStore_GetDEREncodedPrivateKey(keyStore);
EVP_PKEY *privateKey = NULL;
size_t keySize = parcBuffer_Remaining(privateKeyBuffer);
uint8_t *bytes = parcBuffer_Overlay(privateKeyBuffer, keySize);
privateKey = d2i_PrivateKey(EVP_PKEY_RSA, &privateKey, (const unsigned char **) &bytes, keySize);
parcBuffer_Release(&privateKeyBuffer);
RSA *rsa = EVP_PKEY_get1_RSA(privateKey);
int opensslDigestType;
switch (parcCryptoHash_GetDigestType(digestToSign)) {
case PARCCryptoHashType_SHA256:
opensslDigestType = NID_sha256;
break;
case PARCCryptoHashType_SHA512:
opensslDigestType = NID_sha512;
break;
default:
trapUnexpectedState("Unknown digest type: %s",
parcCryptoHashType_ToString(parcCryptoHash_GetDigestType(digestToSign)));
}
uint8_t *sig = parcMemory_Allocate(RSA_size(rsa));
assertNotNull(sig, "parcMemory_Allocate(%u) returned NULL", RSA_size(rsa));
unsigned sigLength = 0;
PARCBuffer *bb_digest = parcCryptoHash_GetDigest(digestToSign);
int result = RSA_sign(opensslDigestType,
(unsigned char *) parcByteArray_Array(parcBuffer_Array(bb_digest)),
(int) parcBuffer_Remaining(bb_digest),
sig,
&sigLength,
rsa);
assertTrue(result == 1, "Got error from RSA_sign: %d", result);
RSA_free(rsa);
PARCBuffer *bbSign = parcBuffer_Allocate(sigLength);
parcBuffer_Flip(parcBuffer_PutArray(bbSign, sigLength, sig));
parcMemory_Deallocate((void **) &sig);
PARCSignature *signature =
parcSignature_Create(_GetSigningAlgorithm(signer),
parcCryptoHash_GetDigestType(digestToSign),
bbSign
);
parcBuffer_Release(&bbSign);
return signature;
}
size_t rsa_key::sign(void* out, size_t out_len, const void* buf, size_t buf_len, int type) const
{
unsigned int _out_len = static_cast<unsigned int>(out_len);
throw_error_if_not(RSA_sign(type, static_cast<const unsigned char*>(buf), static_cast<unsigned int>(buf_len), static_cast<unsigned char*>(out), &_out_len, ptr().get()) != 0);
return _out_len;
}
/* TODO: remove this function in libp11 0.5.0 */
int pkcs11_sign(int type, const unsigned char *m, unsigned int m_len,
unsigned char *sigret, unsigned int *siglen, PKCS11_KEY *key)
{
RSA *rsa = pkcs11_rsa(key);
if (rsa == NULL)
return -1;
return RSA_sign(type, m, m_len, sigret, siglen, rsa);
}
/**
* Sign file using specified rsa key and signature
*
* arguments:
* (rsa_privkey, rsa_signature, string)
*
* returns:
* true - if string match rsa signature
* false - otherwise
*/
static gint
lua_rsa_sign_file (lua_State *L)
{
RSA *rsa;
rspamd_fstring_t *signature, **psig;
const gchar *filename;
gchar *data = NULL, *data_sig;
gint ret, fd;
struct stat st;
rsa = lua_check_rsa_privkey (L, 1);
filename = luaL_checkstring (L, 2);
if (rsa != NULL && filename != NULL) {
fd = open (filename, O_RDONLY);
if (fd == -1) {
msg_err ("cannot open file %s: %s", filename, strerror (errno));
lua_pushnil (L);
}
else {
if (fstat (fd, &st) == -1 ||
(data =
mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd,
0)) == MAP_FAILED) {
msg_err ("cannot mmap file %s: %s", filename, strerror (errno));
lua_pushnil (L);
}
else {
signature = rspamd_fstring_sized_new (RSA_size (rsa));
data_sig = g_compute_checksum_for_string (G_CHECKSUM_SHA256,
data,
st.st_size);
ret = RSA_sign (NID_sha1, data_sig, strlen (data_sig),
signature->str, (guint *)&signature->len, rsa);
if (ret == 0) {
msg_info ("cannot make a signature for data: %s",
ERR_error_string (ERR_get_error (), NULL));
lua_pushnil (L);
rspamd_fstring_free (signature);
}
else {
psig = lua_newuserdata (L, sizeof (rspamd_fstring_t *));
rspamd_lua_setclass (L, "rspamd{rsa_signature}", -1);
*psig = signature;
}
g_free (data_sig);
munmap (data, st.st_size);
}
close (fd);
}
}
else {
lua_pushnil (L);
}
return 1;
}
/**
* SHA1WithRSA私钥签名
*
* LUA示例:
* local codec = require('codec')
* local src = 'something'
* local pem = [[...]] --私钥PEM字符串
* local bs = codec.rsa_private_sign(src, pem)
* local dst = codec.base64_encode(bs) --BASE64签名
*/
static int codec_rsa_private_sign(lua_State *L)
{
size_t len;
const char *src = luaL_checklstring(L, 1, &len);
char *pem = luaL_checkstring(L, 2);
SHA_CTX c;
unsigned char sha[SHA_DIGEST_LENGTH];
memset(sha, 0, SHA_DIGEST_LENGTH);
if(SHA_Init(&c) != 1)
{
OPENSSL_cleanse(&c, sizeof(c));
return luaL_error(L, "SHA init error");
}
if(SHA1_Update(&c, src, len) != 1)
{
OPENSSL_cleanse(&c, sizeof(c));
return luaL_error(L, "SHA update error");
}
if(SHA1_Final(sha, &c) != 1)
{
OPENSSL_cleanse(&c, sizeof(c));
return luaL_error(L, "SHA update error");
}
OPENSSL_cleanse(&c, sizeof(c));
BIO *bio = BIO_new_mem_buf((void *)pem, -1);
if(bio == NULL)
{
BIO_free_all(bio);
return luaL_error(L, "PEM error");
}
RSA *rsa = PEM_read_bio_RSAPrivateKey(bio, NULL, NULL, NULL);
if(rsa == NULL)
{
BIO_free_all(bio);
return luaL_error(L, "RSA read private key error");
}
BIO_free_all(bio);
int n = RSA_size(rsa), wn;
char dst[n];
memset(dst, 0, n);
int ret = RSA_sign(NID_sha1, (unsigned char *)sha, SHA_DIGEST_LENGTH, (unsigned char *)dst, (unsigned int *)&wn,
rsa);
if(ret != 1)
{
RSA_free(rsa);
BIO_free_all(bio);
return luaL_error(L, "RSA sign error");
}
RSA_free(rsa);
lua_pushlstring(L, dst, wn);
return 1;
}
void private_key::sign( const sha1& digest, array<char,2048/8>& sig )const
{
FC_ASSERT( (size_t(RSA_size(my->rsa)) <= sizeof(sig)), "Invalid RSA size" );
uint32_t slen = 0;
if( 1 != RSA_sign( NID_sha1, (uint8_t*)&digest,
20, (unsigned char*)&sig, &slen, my->rsa ) )
{
FC_THROW_EXCEPTION( exception, "rsa sign failed with ${message}", ("message",fc::string(ERR_error_string( ERR_get_error(),NULL))) );
}
}
static void
bench_openssl_rsa_sign (void *p)
{
const struct openssl_rsa_ctx *ctx = p;
unsigned siglen;
if (! RSA_sign (NID_sha1, ctx->digest, SHA1_DIGEST_SIZE,
ctx->signature, &siglen, ctx->key))
die ("OpenSSL RSA_sign failed.\n");
}
