int FLDigiDoc::certRSAKeyValue(const QString &certfile, QByteArray &modResult,
QByteArray &expResult)
{
int err = ERR_OK;
unsigned char buf2[1024 * sizeof(unsigned char)], *buf1 = 0;
unsigned char buf22[1024 * sizeof(unsigned char)], *buf11 = 0;
int len2, len1;
EVP_PKEY *pubKey;
len1 = 512;
buf1 = (unsigned char *) malloc(len1);
memset(buf1, 0, len1);
buf11 = (unsigned char *) malloc(len1);
memset(buf11, 0, len1);
err = ReadPublicKey(&pubKey, certfile.latin1());
// FIXME
// modulus
len1 = BN_bn2bin(pubKey->pkey.rsa->n, buf1);
// in version 1.1 we output modulus as it is
// starting from 1.2 we convert it to big-endian
// len2 = sizeof(buf2);
// memset(buf2, 0, len2);
// encode(buf1, len1, buf2, &len2);
// printf("Old modulus: %s\n", buf2);
// if (!strcmp(pSigDoc->szFormatVer, DIGIDOC_XML_1_1_VER)) {
// swapBytes((byte *)buf1, len1);
// }
len2 = sizeof(buf2);
memset(buf2, 0, len2);
encode(buf1, len1, buf2, &len2);
modResult.duplicate((const char *)buf2, len2);
// exponent
memset(buf11, 0, len1);
len1 = BN_bn2bin(pubKey->pkey.rsa->e, buf11);
len2 = sizeof(buf22);
memset(buf22, 0, len2);
encode(buf11, len1, buf22, &len2);
expResult.duplicate((const char *)buf22, len2);
EVP_PKEY_free(pubKey);
free(buf1);
free(buf11);
return err;
}
int main()
{
char *ct = "This the clear text";
char *buf;
char *buf2;
EVP_PKEY *pubKey;
EVP_PKEY *privKey;
int len;
ERR_load_crypto_strings();
privKey = ReadPrivateKey(PRIVFILE);
if (!privKey)
{
ERR_print_errors_fp (stderr);
exit (1);
}
pubKey = ReadPublicKey(PUBFILE);
if(!pubKey)
{
EVP_PKEY_free(privKey);
fprintf(stderr,"Error: can't load public key");
exit(1);
}
/* No error checking */
buf = malloc(EVP_PKEY_size(pubKey));
buf2 = malloc(EVP_PKEY_size(pubKey));
len = RSA_public_encrypt(strlen(ct)+1, ct, buf, pubKey->pkey.rsa,RSA_PKCS1_PADDING);
if (len != EVP_PKEY_size(pubKey))
{
fprintf(stderr,"Error: ciphertext should match length of key\n");
exit(1);
}
RSA_private_decrypt(len, buf, buf2, privKey->pkey.rsa,RSA_PKCS1_PADDING);
printf("%s\n", buf2);
EVP_PKEY_free(privKey);
EVP_PKEY_free(pubKey);
free(buf);
free(buf2);
return 0;
}
void main_encrypt(void)
{
unsigned int ebuflen;
EVP_CIPHER_CTX ectx;
unsigned char iv[EVP_MAX_IV_LENGTH];
unsigned char *ekey[1];
int readlen;
int ekeylen, net_ekeylen;
EVP_PKEY *pubKey[1];
char buf[512];
char ebuf[512];
memset(iv, '\0', sizeof(iv));
pubKey[0] = ReadPublicKey(PUBFILE);
if(!pubKey)
{
fprintf(stderr,"Error: can't load public key");
exit(1);
}
ekey[0] = malloc(EVP_PKEY_size(pubKey[0]));
if (!ekey[0])
{
EVP_PKEY_free(pubKey[0]);
perror("malloc");
exit(1);
}
EVP_SealInit(&ectx,
EVP_des_ede3_cbc(),
ekey,
&ekeylen,
iv,
pubKey,
1);
net_ekeylen = htonl(ekeylen);
write(STDOUT, (char*)&net_ekeylen, sizeof(net_ekeylen));
write(STDOUT, ekey[0], ekeylen);
write(STDOUT, iv, sizeof(iv));
while(1)
{
readlen = read(STDIN, buf, sizeof(buf));
if (readlen <= 0)
{
if (readlen < 0)
perror("read");
break;
}
EVP_SealUpdate(&ectx, ebuf, &ebuflen, buf, readlen);
write(STDOUT, ebuf, ebuflen);
}
EVP_SealFinal(&ectx, ebuf, &ebuflen);
write(STDOUT, ebuf, ebuflen);
EVP_PKEY_free(pubKey[0]);
free(ekey[0]);
}
