abc/GmSSL
1
0
Fork 0
mirror of https://github.com/guanzhi/GmSSL.git synced 2026-08-08 23:13:38 +08:00
Code Issues Packages Projects Releases Wiki Activity

update pmeth/ameth

Browse Source
This commit is contained in:
Zhi Guan
2018-11-28 16:15:06 +08:00
parent 9fe7aa1280
commit 5f3bb5c346
22 changed files with 1065 additions and 5223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
crypto/paillier/build.info
View File

@@ -1,2 +1,3 @@
LIBS=../../libcrypto
SOURCE[../../libcrypto]=pai_lib.c pai_err.c pai_asn1.c pai_ameth.c
SOURCE[../../libcrypto]=pai_lib.c pai_err.c pai_asn1.c pai_ameth.c \
pai_pmeth.c

55
crypto/paillier/pai_ameth.c
View File

@@ -225,31 +225,32 @@ static int old_paillier_priv_encode(const EVP_PKEY *pkey, unsigned char **pder)
}
const EVP_PKEY_ASN1_METHOD paillier_asn1_meth = {
EVP_PKEY_PAILLIER,
EVP_PKEY_PAILLIER,
0, //FIXME
"PAILLIER",
"OpenSSL PAILLIER algorithm",
paillier_pub_decode,
paillier_pub_encode,
paillier_pub_cmp,
paillier_pub_print,
paillier_priv_decode,
paillier_priv_encode,
paillier_priv_print,
int_paillier_size,
paillier_bits,
paillier_security_bits,
0, 0, 0, 0, 0, 0,
0,
int_paillier_free,
paillier_pkey_ctrl,
old_paillier_priv_decode,
old_paillier_priv_encode
EVP_PKEY_PAILLIER, /* pkey_id */
EVP_PKEY_PAILLIER, /* pkey_base_id */
0, /* pkey_flags */
"PAILLIER", /* pem_str */
"GmSSL Paillier algorithm", /* info */
paillier_pub_decode, /* pub_decode */
paillier_pub_encode, /* pub_encode */
paillier_pub_cmp, /* pub_cmp */
paillier_pub_print, /* pub_print */
paillier_priv_decode, /* priv_decode */
paillier_priv_encode, /* priv_encode */
paillier_priv_print, /* priv_print */
int_paillier_size, /* pkey_size */
paillier_bits, /* pkey_bits */
paillier_security_bits, /* pkey_security_bits */
NULL, /* param_decode */
NULL, /* param_encode */
NULL, /* param_missing */
NULL, /* param_copy */
NULL, /* param_cmp */
NULL, /* param_print */
NULL, /* sig_print */
int_paillier_free, /* pkey_free */
paillier_pkey_ctrl, /* pkey_ctrl */
old_paillier_priv_decode, /* old_priv_decode */
old_paillier_priv_encode, /* old_priv_encode */
NULL, /* item_verify */
NULL, /* item_sign */
};

6
crypto/paillier/pai_err.c
View File

@@ -32,8 +32,12 @@ static ERR_STRING_DATA PAILLIER_str_functs[] = {
{ERR_FUNC(PAILLIER_F_PAILLIER_PRIV_DECODE), "paillier_priv_decode"},
{ERR_FUNC(PAILLIER_F_PAILLIER_PRIV_ENCODE), "paillier_priv_encode"},
{ERR_FUNC(PAILLIER_F_PAILLIER_PUB_DECODE), "paillier_pub_decode"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_CTRL), "pkey_paillier_ctrl"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_CTRL_STR), "pkey_paillier_ctrl_str"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_DECRYPT), "pkey_paillier_decrypt"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_ENCRYPT), "pkey_paillier_encrypt"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_INIT), "pkey_paillier_init"},
{ERR_FUNC(PAILLIER_F_PKEY_PAILLIER_KEYGEN), "pkey_paillier_keygen"},
{0, NULL}
};
@@ -42,8 +46,10 @@ static ERR_STRING_DATA PAILLIER_str_reasons[] = {
{ERR_REASON(PAILLIER_R_DECODE_ERROR), "decode error"},
{ERR_REASON(PAILLIER_R_GENERATE_PRIME_FAILED), "generate prime failed"},
{ERR_REASON(PAILLIER_R_INVALID_PLAINTEXT), "invalid plaintext"},
{ERR_REASON(PAILLIER_R_KEY_SIZE_TOO_SMALL), "key size too small"},
{ERR_REASON(PAILLIER_R_MALLOC_FAILED), "malloc failed"},
{ERR_REASON(PAILLIER_R_NOT_IMPLEMENTED), "not implemented"},
{ERR_REASON(PAILLIER_R_VALUE_MISSING), "value missing"},
{0, NULL}
};

1
crypto/paillier/pai_lcl.h
View File

@@ -67,4 +67,3 @@ struct paillier_st {
};
#endif

98
crypto/paillier/pai_lib.c
View File

@@ -81,7 +81,7 @@ void PAILLIER_free(PAILLIER *key)
int PAILLIER_size(const PAILLIER *key)
{
return BN_num_bits(key->n)/8;
return (BN_num_bits(key->n) * 2)/8;
}
int PAILLIER_security_bits(const PAILLIER *key)
@@ -100,57 +100,60 @@ int PAILLIER_generate_key(PAILLIER *key, int bits)
q = BN_new();
bn_ctx = BN_CTX_new();
if (!key->n) key->n = BN_new();
if (!key->lambda) key->lambda = BN_new();
if (!key->n_squared) key->n_squared = BN_new();
if (!key->n_plusone) key->n_plusone = BN_new();
if (!key->x) key->x = BN_new();
if (!key->n)
key->n = BN_new();
if (!key->lambda)
key->lambda = BN_new();
if (!key->n_squared)
key->n_squared = BN_new();
if (!key->n_plusone)
key->n_plusone = BN_new();
if (!key->x)
key->x = BN_new();
if (!p || !q || !bn_ctx || !key->n || !key->lambda ||
!key->n_squared || !key->n_plusone || !key->x) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY, ERR_R_MALLOC_FAILURE);
goto end;
}
key->bits = bits;
do {
if (!BN_generate_prime_ex(p, bits, 0, NULL, NULL, NULL)) {
if (!BN_generate_prime_ex(p, bits/2, 0, NULL, NULL, NULL)) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY,
PAILLIER_R_GENERATE_PRIME_FAILED);
goto end;
}
if (!BN_generate_prime_ex(q, bits, 0, NULL, NULL, NULL)) {
if (!BN_generate_prime_ex(q, bits/2, 0, NULL, NULL, NULL)) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY,
PAILLIER_R_GENERATE_PRIME_FAILED);
goto end;
}
if (!BN_mul(key->n, p, q, bn_ctx)) {
if (!BN_mul(key->n, p, q, bn_ctx)
|| !BN_sub_word(p, 1)
|| !BN_sub_word(q, 1)
/* lambda = (p - 1)*(q - 1) */
|| !BN_mul(key->lambda, p, q, bn_ctx)
/* n_squared = n^2 */
|| !BN_sqr(key->n_squared, key->n, bn_ctx)
/* n_plusone = n + 1 */
|| !BN_copy(key->n_plusone, key->n)
|| !BN_add_word(key->n_plusone, 1)
#if 0
/* x = (((g^lambda mod n^2) - 1)/n)^-1 mod n */
|| !BN_mod_exp(key->x, key->n_plusone, key->lambda, key->n_squared, bn_ctx)
|| !BN_sub_word(key->x, 1)
|| !BN_div(key->x, key->x, key->n)
|| !BN_mod_inverse(key->x, key->x, key->n, bn_ctx)
#endif
) {
PAILLIERerr(PAILLIER_F_PAILLIER_GENERATE_KEY, ERR_R_BN_LIB);
goto end;
}
if (!BN_sub_word(p, 1)) {
goto end;
}
if (!BN_sub_word(q, 1)) {
goto end;
}
if (!BN_mul(key->lambda, p, q, bn_ctx)) {
goto end;
}
BN_sqr(key->n_squared, key->n, bn_ctx);
BN_copy(key->n_plusone, key->n);
BN_add_word(key->n_plusone, 1);
/*
BN_mod_exp(key->x, key->n_plusone, key->lambda, key->n_squared, bn_ctx);
BN_sub_word(key->x, 1);
BN_div(key->x, key->x, key->n);
BN_mod_inverse(key->x, key->x, key->n, bn_ctx);
*/
} while (0);
ret = 1;
@@ -173,6 +176,9 @@ int PAILLIER_encrypt(BIGNUM *c, const BIGNUM *m, PAILLIER *pub_key)
BIGNUM *r = NULL;
BN_CTX *bn_ctx = NULL;
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (BN_cmp(m, pub_key->n) >= 0) {
PAILLIERerr(PAILLIER_F_PAILLIER_ENCRYPT, PAILLIER_R_INVALID_PLAINTEXT);
goto end;
@@ -249,22 +255,54 @@ int PAILLIER_decrypt(BIGNUM *m, const BIGNUM *c, PAILLIER *key)
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
/*
printf("m = %s\n", BN_bn2hex(m));
printf("c = %s\n", BN_bn2hex(c));
printf("lambda = %s\n", BN_bn2hex(key->lambda));
printf("n^2 = %s\n", BN_bn2hex(key->n_squared));
*/
if (!key->n_squared) {
if (!(key->n_squared = BN_new())) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!BN_sqr(key->n_squared, key->n, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_mod_exp(m, c, key->lambda, key->n_squared, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_sub_word(m, 1)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_div(m, NULL, m, key->n, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
fprintf(stderr, "%s %d: m = %s\n", __FILE__, __LINE__, BN_bn2hex(m));
if (!BN_mod_mul(m, m, key->x, key->n, bn_ctx)) {
PAILLIERerr(PAILLIER_F_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
printf("m = %s\n", BN_bn2hex(m));
ret = 1;
end:
BN_CTX_free(bn_ctx);

137
crypto/paillier/pai_pmeth.c
View File

@@ -49,37 +49,76 @@
#include <stdio.h>
#include <openssl/evp.h>
#include <openssl/err.h>
#include <openssl/paillier.h>
#include "internal/evp_int.h"
#include "pai_lcl.h"
typedef struct {
int flags;
int bits;
} PAILLIER_PKEY_CTX;
static int pkey_paillier_init(EVP_PKEY_CTX *ctx)
{
PAILLIER_PKEY_CTX *dctx;
if (!(dctx = OPENSSL_zalloc(sizeof(*dctx)))) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_INIT, ERR_R_MALLOC_FAILURE);
return 0;
}
dctx->bits = 4096;
(void)EVP_PKEY_CTX_set_data(ctx, dctx);
return 1;
}
static int pkey_paillier_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
{
PAILLIER_PKEY_CTX *dctx;
PAILLIER_PKEY_CTX *sctx;
if (!pkey_paillier_init(dst))
return 0;
dctx = EVP_PKEY_CTX_get_data(dst);
sctx = EVP_PKEY_CTX_get_data(src);
OPENSSL_assert(sctx);
*dctx = *sctx;
return 1;
}
static void pkey_paillier_cleanup(EVP_PKEY_CTX *ctx)
{
PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
if (dctx) {
OPENSSL_free(dctx);
}
}
static int pkey_paillier_keygen(EVP_PKEY_CTX *ctx, EVP_PKEY *pkey)
{
PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
PAILLIER *pai = NULL;
if (!(pai = PAILLIER_new())) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_MALLOC_FAILURE);
return 0;
}
if (!EVP_PKEY_assign_PAILLIER(pkey, pai)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_EVP_LIB);
PAILLIER_free(pai);
return 0;
}
if (!PAILLIER_generate_key(EVP_PKEY_get0_PAILLIER(pkey), dctx->bits)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_KEYGEN, ERR_R_PAILLIER_LIB);
return 0;
}
return 1;
}
static int pkey_paillier_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
const unsigned char *in, size_t inlen)
{
int ret = 0;
PAILLIER *key = ctx->pkey->pkey.paillier;
PAILLIER *key = EVP_PKEY_get0_PAILLIER(EVP_PKEY_CTX_get0_pkey(ctx));
BIGNUM *m = NULL;
BIGNUM *c = NULL;
//FIXME: check inlen
if (!out) {
*outlen = PAILLIER_size(key);
return 1;
@@ -92,20 +131,21 @@ static int pkey_paillier_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!BN_bin2bn(in, (int)inlen, m)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_BN_LIB);
goto end;
}
if (!PAILLIER_encrypt(c, m, key)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_ENCRYPT, ERR_R_PAILLIER_LIB);
goto end;
}
/* the ciphertext has no prefix zeros */
*outlen = BN_bn2bin(c, out);
ret = 1;
end:
BN_free(m);
BN_clear_free(m);
BN_free(c);
return ret;
}
@@ -114,7 +154,7 @@ static int pkey_paillier_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
const unsigned char *in, size_t inlen)
{
int ret = 0;
PAILLIER *key = ctx->pkey->pkey.paillier;
PAILLIER *key = EVP_PKEY_get0_PAILLIER(EVP_PKEY_CTX_get0_pkey(ctx));
BIGNUM *m = NULL;
BIGNUM *c = NULL;
@@ -130,15 +170,16 @@ static int pkey_paillier_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_MALLOC_FAILURE);
goto end;
}
if (!BN_bin2bn(in, (int)inlen, c)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_BN_LIB);
goto end;
}
if (!PAILLIER_decrypt(m, c, key)) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_DECRYPT, ERR_R_PAILLIER_LIB);
goto end;
}
/* the plaintext has no prefix zeros */
*outlen = BN_bn2bin(m, out);
ret = 1;
end:
@@ -149,43 +190,61 @@ end:
static int pkey_paillier_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
{
return 0;
PAILLIER_PKEY_CTX *dctx = EVP_PKEY_CTX_get_data(ctx);
switch (type) {
case EVP_PKEY_CTRL_PAILLIER_KEYGEN_BITS:
if (p1 < PAILLIER_MIN_KEY_BITS) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_CTRL, PAILLIER_R_KEY_SIZE_TOO_SMALL);
return -2;
}
dctx->bits = p1;
return 1;
}
return -2;
}
static int pkey_paillier_ctrl_str(EVP_PKEY_CTX *ctx,
const char *type, const char *value)
static int pkey_paillier_ctrl_str(EVP_PKEY_CTX *ctx, const char *type, const char *value)
{
return 0;
if (!value) {
PAILLIERerr(PAILLIER_F_PKEY_PAILLIER_CTRL_STR, PAILLIER_R_VALUE_MISSING);
return 0;
}
if (!strcmp(type, "bits")) {
int nbits = atoi(value);
return EVP_PKEY_CTX_set_paillier_keygen_bits(ctx, nbits);
}
return -2;
}
#define EVP_PKEY_PAILLIER NID_paillier
const EVP_PKEY_METHOD paillier_pmeth = {
EVP_PKEY_PAILLIER,
0,
pkey_paillier_init,
pkey_paillier_copy,
pkey_paillier_cleanup,
0, 0,
0,
pkey_paillier_keygen,
0, 0,
0, 0,
0, 0,
0, 0, 0, 0,
0,
pkey_paillier_encrypt,
0,
pkey_paillier_decrypt,
0, 0,
pkey_paillier_ctrl,
pkey_paillier_ctrl_str
const EVP_PKEY_METHOD paillier_pkey_meth = {
EVP_PKEY_PAILLIER, /* pkey_id */
0, /* flags */
pkey_paillier_init, /* init */
pkey_paillier_copy, /* copy */
pkey_paillier_cleanup, /* cleanup */
NULL, /* paramgen_init */
NULL, /* paramgen */
NULL, /* keygen_init */
pkey_paillier_keygen, /* keygen */
NULL, /* sign_init */
NULL, /* sign */
NULL, /* verify_init */
NULL, /* verify */
NULL, /* verify_recover_init */
NULL, /* verify_recover */
NULL, /* signctx_init */
NULL, /* signctx */
NULL, /* verifyctx_init */
NULL, /* verifyctx */
NULL, /* encrypt_init */
pkey_paillier_encrypt, /* encrypt */
NULL, /* decrypt_init */
pkey_paillier_decrypt, /* decrypt */
NULL, /* derive_init */
NULL, /* derive */
pkey_paillier_ctrl, /* ctrl */
pkey_paillier_ctrl_str /* ctrl_str */
};