mirror of
https://github.com/guanzhi/GmSSL.git
synced 2026-08-09 15:33:58 +08:00
Remove some ciphers
This commit is contained in:
Zhi Guan
@@ -1,101 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
#include <openssl/ec_type1.h>
|
||||
#include <openssl/bb1ibe.h>
|
||||
#include "bb1ibe_lcl.h"
|
||||
|
||||
ASN1_SEQUENCE(BB1PublicParameters) = {
|
||||
ASN1_SIMPLE(BB1PublicParameters, version, LONG),
|
||||
ASN1_SIMPLE(BB1PublicParameters, curve, ASN1_OBJECT),
|
||||
ASN1_SIMPLE(BB1PublicParameters, p, BIGNUM),
|
||||
ASN1_SIMPLE(BB1PublicParameters, q, BIGNUM),
|
||||
ASN1_SIMPLE(BB1PublicParameters, pointP, FpPoint),
|
||||
ASN1_SIMPLE(BB1PublicParameters, pointP1, FpPoint),
|
||||
ASN1_SIMPLE(BB1PublicParameters, pointP2, FpPoint),
|
||||
ASN1_SIMPLE(BB1PublicParameters, pointP3, FpPoint),
|
||||
ASN1_SIMPLE(BB1PublicParameters, v, FpPoint),
|
||||
ASN1_SIMPLE(BB1PublicParameters, hashfcn, ASN1_OBJECT)
|
||||
} ASN1_SEQUENCE_END(BB1PublicParameters)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BB1PublicParameters)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BB1PublicParameters)
|
||||
|
||||
ASN1_SEQUENCE(BB1MasterSecret) = {
|
||||
ASN1_SIMPLE(BB1MasterSecret, version, LONG),
|
||||
ASN1_SIMPLE(BB1MasterSecret, alpha, BIGNUM),
|
||||
ASN1_SIMPLE(BB1MasterSecret, beta, BIGNUM),
|
||||
ASN1_SIMPLE(BB1MasterSecret, gamma, BIGNUM)
|
||||
} ASN1_SEQUENCE_END(BB1MasterSecret)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BB1MasterSecret)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BB1MasterSecret)
|
||||
|
||||
ASN1_SEQUENCE(BB1PrivateKeyBlock) = {
|
||||
ASN1_SIMPLE(BB1PrivateKeyBlock, version, LONG),
|
||||
ASN1_SIMPLE(BB1PrivateKeyBlock, pointD0, FpPoint),
|
||||
ASN1_SIMPLE(BB1PrivateKeyBlock, pointD1, FpPoint)
|
||||
} ASN1_SEQUENCE_END(BB1PrivateKeyBlock)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BB1PrivateKeyBlock)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BB1PrivateKeyBlock)
|
||||
|
||||
ASN1_SEQUENCE(BB1CiphertextBlock) = {
|
||||
ASN1_SIMPLE(BB1CiphertextBlock, version, LONG),
|
||||
ASN1_SIMPLE(BB1CiphertextBlock, pointChi0, FpPoint),
|
||||
ASN1_SIMPLE(BB1CiphertextBlock, pointChi1, FpPoint),
|
||||
ASN1_SIMPLE(BB1CiphertextBlock, nu, BIGNUM),
|
||||
ASN1_SIMPLE(BB1CiphertextBlock, y, ASN1_OCTET_STRING)
|
||||
} ASN1_SEQUENCE_END(BB1CiphertextBlock)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BB1CiphertextBlock)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BB1CiphertextBlock)
|
||||
|
||||
@@ -1,68 +0,0 @@
|
||||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT
|
||||
* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/bb1ibe.h>
|
||||
|
||||
/* BEGIN ERROR CODES */
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
# define ERR_FUNC(func) ERR_PACK(ERR_LIB_BB1IBE,func,0)
|
||||
# define ERR_REASON(reason) ERR_PACK(ERR_LIB_BB1IBE,0,reason)
|
||||
|
||||
static ERR_STRING_DATA BB1IBE_str_functs[] = {
|
||||
{ERR_FUNC(BB1IBE_F_BB1CIPHERTEXTBLOCK_HASH_TO_RANGE),
|
||||
"BB1CiphertextBlock_hash_to_range"},
|
||||
{ERR_FUNC(BB1IBE_F_BB1IBE_DECRYPT), "BB1IBE_decrypt"},
|
||||
{ERR_FUNC(BB1IBE_F_BB1IBE_DOUBLE_HASH), "BB1IBE_double_hash"},
|
||||
{ERR_FUNC(BB1IBE_F_BB1IBE_DO_DECRYPT), "BB1IBE_do_decrypt"},
|
||||
{ERR_FUNC(BB1IBE_F_BB1IBE_DO_ENCRYPT), "BB1IBE_do_encrypt"},
|
||||
{ERR_FUNC(BB1IBE_F_BB1IBE_ENCRYPT), "BB1IBE_encrypt"},
|
||||
{ERR_FUNC(BB1IBE_F_BB1IBE_EXTRACT_PRIVATE_KEY),
|
||||
"BB1IBE_extract_private_key"},
|
||||
{ERR_FUNC(BB1IBE_F_BB1IBE_SETUP), "BB1IBE_setup"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static ERR_STRING_DATA BB1IBE_str_reasons[] = {
|
||||
{ERR_REASON(BB1IBE_R_BB1CIPHERTEXT_INVALID_MAC),
|
||||
"bb1ciphertext invalid mac"},
|
||||
{ERR_REASON(BB1IBE_R_BB1IBE_HASH_FAILURE), "bb1ibe hash failure"},
|
||||
{ERR_REASON(BB1IBE_R_BUFFER_TOO_SMALL), "buffer too small"},
|
||||
{ERR_REASON(BB1IBE_R_COMPUTE_OUTLEN_FAILURE), "compute outlen failure"},
|
||||
{ERR_REASON(BB1IBE_R_COMPUTE_TATE_FAILURE), "compute tate failure"},
|
||||
{ERR_REASON(BB1IBE_R_D2I_FAILURE), "d2i failure"},
|
||||
{ERR_REASON(BB1IBE_R_DECRYPT_FAILURE), "decrypt failure"},
|
||||
{ERR_REASON(BB1IBE_R_DOUBLE_HASH_FAILURE), "double hash failure"},
|
||||
{ERR_REASON(BB1IBE_R_ENCRYPT_FAILURE), "encrypt failure"},
|
||||
{ERR_REASON(BB1IBE_R_I2D_FAILURE), "i2d failure"},
|
||||
{ERR_REASON(BB1IBE_R_INVALID_INPUT), "invalid input"},
|
||||
{ERR_REASON(BB1IBE_R_INVALID_MD), "invalid md"},
|
||||
{ERR_REASON(BB1IBE_R_INVALID_OUTPUT_BUFFER), "invalid output buffer"},
|
||||
{ERR_REASON(BB1IBE_R_INVALID_TYPE1CURVE), "invalid type1curve"},
|
||||
{ERR_REASON(BB1IBE_R_NOT_NAMED_CURVE), "not named curve"},
|
||||
{ERR_REASON(BB1IBE_R_PARSE_PAIRING), "parse pairing"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
int ERR_load_BB1IBE_strings(void)
|
||||
{
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
if (ERR_func_error_string(BB1IBE_str_functs[0].error) == NULL) {
|
||||
ERR_load_strings(0, BB1IBE_str_functs);
|
||||
ERR_load_strings(0, BB1IBE_str_reasons);
|
||||
}
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
@@ -1,93 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
#include <openssl/ec_type1.h>
|
||||
#include <openssl/bb1ibe.h>
|
||||
|
||||
|
||||
struct BB1PublicParameters_st {
|
||||
long version;
|
||||
ASN1_OBJECT *curve;
|
||||
BIGNUM *p;
|
||||
BIGNUM *q;
|
||||
FpPoint *pointP;
|
||||
FpPoint *pointP1;
|
||||
FpPoint *pointP2;
|
||||
FpPoint *pointP3;
|
||||
FpPoint *v;
|
||||
ASN1_OBJECT *hashfcn;
|
||||
};
|
||||
|
||||
struct BB1MasterSecret_st {
|
||||
long version;
|
||||
BIGNUM *alpha;
|
||||
BIGNUM *beta;
|
||||
BIGNUM *gamma;
|
||||
};
|
||||
|
||||
struct BB1PrivateKeyBlock_st {
|
||||
long version;
|
||||
FpPoint *pointD0;
|
||||
FpPoint *pointD1;
|
||||
};
|
||||
|
||||
struct BB1CiphertextBlock_st {
|
||||
long version;
|
||||
FpPoint *pointChi0;
|
||||
FpPoint *pointChi1;
|
||||
BIGNUM *nu;
|
||||
ASN1_OCTET_STRING *y;
|
||||
};
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,2 +0,0 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=bb1ibe_err.c bb1ibe_asn1.c bb1ibe_lib.c
|
||||
@@ -1,100 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <openssl/ec.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/ec_type1.h>
|
||||
#include <openssl/ec_hash.h>
|
||||
#include <openssl/bfibe.h>
|
||||
#include <openssl/rand.h>
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
#include <openssl/kdf.h>
|
||||
#include "bfibe_lcl.h"
|
||||
|
||||
ASN1_SEQUENCE(BFPublicParameters) = {
|
||||
ASN1_SIMPLE(BFPublicParameters, version, LONG),
|
||||
ASN1_SIMPLE(BFPublicParameters, curve, ASN1_OBJECT),
|
||||
ASN1_SIMPLE(BFPublicParameters, p, BIGNUM),
|
||||
ASN1_SIMPLE(BFPublicParameters, q, BIGNUM),
|
||||
ASN1_SIMPLE(BFPublicParameters, pointP, FpPoint),
|
||||
ASN1_SIMPLE(BFPublicParameters, pointPpub, FpPoint),
|
||||
ASN1_SIMPLE(BFPublicParameters, hashfcn, ASN1_OBJECT)
|
||||
} ASN1_SEQUENCE_END(BFPublicParameters)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BFPublicParameters)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BFPublicParameters)
|
||||
|
||||
ASN1_SEQUENCE(BFMasterSecret) = {
|
||||
ASN1_SIMPLE(BFMasterSecret, version, LONG),
|
||||
ASN1_SIMPLE(BFMasterSecret, masterSecret, BIGNUM)
|
||||
} ASN1_SEQUENCE_END(BFMasterSecret)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BFMasterSecret)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BFMasterSecret)
|
||||
|
||||
ASN1_SEQUENCE(BFPrivateKeyBlock) = {
|
||||
ASN1_SIMPLE(BFPrivateKeyBlock, version, LONG),
|
||||
ASN1_SIMPLE(BFPrivateKeyBlock, privateKey, FpPoint)
|
||||
} ASN1_SEQUENCE_END(BFPrivateKeyBlock)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BFPrivateKeyBlock)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BFPrivateKeyBlock)
|
||||
|
||||
ASN1_SEQUENCE(BFCiphertextBlock) = {
|
||||
ASN1_SIMPLE(BFCiphertextBlock, version, LONG),
|
||||
ASN1_SIMPLE(BFCiphertextBlock, u, FpPoint),
|
||||
ASN1_SIMPLE(BFCiphertextBlock, v, ASN1_OCTET_STRING),
|
||||
ASN1_SIMPLE(BFCiphertextBlock, w, ASN1_OCTET_STRING),
|
||||
} ASN1_SEQUENCE_END(BFCiphertextBlock)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(BFCiphertextBlock)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(BFCiphertextBlock)
|
||||
|
||||
@@ -1,66 +0,0 @@
|
||||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT
|
||||
* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/bfibe.h>
|
||||
|
||||
/* BEGIN ERROR CODES */
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
# define ERR_FUNC(func) ERR_PACK(ERR_LIB_BFIBE,func,0)
|
||||
# define ERR_REASON(reason) ERR_PACK(ERR_LIB_BFIBE,0,reason)
|
||||
|
||||
static ERR_STRING_DATA BFIBE_str_functs[] = {
|
||||
{ERR_FUNC(BFIBE_F_BFIBE_DECRYPT), "BFIBE_decrypt"},
|
||||
{ERR_FUNC(BFIBE_F_BFIBE_DO_DECRYPT), "BFIBE_do_decrypt"},
|
||||
{ERR_FUNC(BFIBE_F_BFIBE_DO_ENCRYPT), "BFIBE_do_encrypt"},
|
||||
{ERR_FUNC(BFIBE_F_BFIBE_ENCRYPT), "BFIBE_encrypt"},
|
||||
{ERR_FUNC(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY),
|
||||
"BFIBE_extract_private_key"},
|
||||
{ERR_FUNC(BFIBE_F_BFIBE_SETUP), "BFIBE_setup"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static ERR_STRING_DATA BFIBE_str_reasons[] = {
|
||||
{ERR_REASON(BFIBE_R_BFIBE_CIPHERTEXT_FAILURE),
|
||||
"bfibe ciphertext failure"},
|
||||
{ERR_REASON(BFIBE_R_BUFFER_TOO_SMALL), "buffer too small"},
|
||||
{ERR_REASON(BFIBE_R_COMPUTE_OUTLEN_FAILURE), "compute outlen failure"},
|
||||
{ERR_REASON(BFIBE_R_D2I_FAILURE), "d2i failure"},
|
||||
{ERR_REASON(BFIBE_R_DECRYPT_FAILURE), "decrypt failure"},
|
||||
{ERR_REASON(BFIBE_R_ENCRYPT_FAILURE), "encrypt failure"},
|
||||
{ERR_REASON(BFIBE_R_HASH_BYTES_FAILURE), "hash bytes failure"},
|
||||
{ERR_REASON(BFIBE_R_I2D_FAILURE), "i2d failure"},
|
||||
{ERR_REASON(BFIBE_R_INVALID_BFIBE_HASHFUNC), "invalid bfibe hashfunc"},
|
||||
{ERR_REASON(BFIBE_R_INVALID_CIPHERTEXT), "invalid ciphertext"},
|
||||
{ERR_REASON(BFIBE_R_INVALID_TYPE1CURVE), "invalid type1curve"},
|
||||
{ERR_REASON(BFIBE_R_KDF_FAILURE), "kdf failure"},
|
||||
{ERR_REASON(BFIBE_R_NOT_NAMED_CURVE), "not named curve"},
|
||||
{ERR_REASON(BFIBE_R_PARSE_CURVE_FAILURE), "parse curve failure"},
|
||||
{ERR_REASON(BFIBE_R_PARSE_MPK_FAILURE), "parse mpk failure"},
|
||||
{ERR_REASON(BFIBE_R_PARSE_PAIRING), "parse pairing"},
|
||||
{ERR_REASON(BFIBE_R_RAND_FAILURE), "rand failure"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
int ERR_load_BFIBE_strings(void)
|
||||
{
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
if (ERR_func_error_string(BFIBE_str_functs[0].error) == NULL) {
|
||||
ERR_load_strings(0, BFIBE_str_functs);
|
||||
ERR_load_strings(0, BFIBE_str_reasons);
|
||||
}
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
@@ -1,102 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <openssl/ec.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/ec_type1.h>
|
||||
#include <openssl/ec_hash.h>
|
||||
#include <openssl/bfibe.h>
|
||||
#include <openssl/rand.h>
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
#include <openssl/kdf.h>
|
||||
|
||||
/*
|
||||
* the `curve` attribute of BFPublicParameters is the OID present the
|
||||
* `type1curve` which is E: y^2 = x^3 + 1 over prime field. It is not an
|
||||
* elliptic curve domain parameters composed of (p, a, b, G, n, h).
|
||||
* For type-1 curve, a = 0, b = 1.
|
||||
* q (i.e. the n in ec params) is the order of generator G, is a prime.
|
||||
* When q is a solinas prime, the scalar mulitiplication computation can
|
||||
* be reduced.
|
||||
* zeta (i.e. h in ec params) = (p + 1)/q. In normall ecc, h is very small
|
||||
* such as 1 or 4. But in pairing, the zeta (or h) is very large.
|
||||
*/
|
||||
struct BFPublicParameters_st {
|
||||
long version;
|
||||
ASN1_OBJECT *curve;
|
||||
BIGNUM *p;
|
||||
BIGNUM *q;
|
||||
FpPoint *pointP;
|
||||
FpPoint *pointPpub;
|
||||
ASN1_OBJECT *hashfcn;
|
||||
};
|
||||
|
||||
struct BFMasterSecret_st {
|
||||
long version;
|
||||
BIGNUM *masterSecret;
|
||||
};
|
||||
|
||||
struct BFPrivateKeyBlock_st {
|
||||
long version;
|
||||
FpPoint *privateKey;
|
||||
};
|
||||
|
||||
struct BFCiphertextBlock_st {
|
||||
long version;
|
||||
FpPoint *u;
|
||||
ASN1_OCTET_STRING *v;
|
||||
ASN1_OCTET_STRING *w;
|
||||
};
|
||||
|
||||
@@ -1,712 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/ec.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/ec_type1.h>
|
||||
#include <openssl/ec_hash.h>
|
||||
#include <openssl/bfibe.h>
|
||||
#include <openssl/rand.h>
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
#include <openssl/kdf.h>
|
||||
#include <openssl/kdf2.h>
|
||||
#include "bfibe_lcl.h"
|
||||
|
||||
|
||||
int BFIBE_setup(const EC_GROUP *group, const EVP_MD *md,
|
||||
BFPublicParameters **pmpk, BFMasterSecret **pmsk)
|
||||
{
|
||||
int ret = 0;
|
||||
BFPublicParameters *mpk = NULL;
|
||||
BFMasterSecret *msk = NULL;
|
||||
BN_CTX *bn_ctx = NULL;
|
||||
EC_POINT *point = NULL;
|
||||
BIGNUM *a;
|
||||
BIGNUM *b;
|
||||
|
||||
if (!group || !pmpk || !pmsk) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!(bn_ctx = BN_CTX_new())) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
a = BN_CTX_get(bn_ctx);
|
||||
b = BN_CTX_get(bn_ctx);
|
||||
if (!b) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
mpk = BFPublicParameters_new();
|
||||
msk = BFMasterSecret_new();
|
||||
point = EC_POINT_new(group);
|
||||
|
||||
if (!mpk || !msk || !point) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* set mpk->version
|
||||
* set mpk->curve
|
||||
*/
|
||||
|
||||
mpk->version = BFIBE_VERSION;
|
||||
|
||||
OPENSSL_assert(mpk->curve);
|
||||
ASN1_OBJECT_free(mpk->curve);
|
||||
if (!(mpk->curve = OBJ_nid2obj(NID_type1curve))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, BFIBE_R_NOT_NAMED_CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* mpk->p = group->p */
|
||||
if (!EC_GROUP_get_curve_GFp(group, mpk->p, a, b, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_is_zero(a) || !BN_is_one(b)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, BFIBE_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* mpk->q = group->order */
|
||||
if (!EC_GROUP_get_order(group, mpk->q, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, BFIBE_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* mpk->pointP = group->generator */
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, EC_GROUP_get0_generator(group),
|
||||
mpk->pointP->x, mpk->pointP->y, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* set mpk->hashfcn from F_p^2 element bits */
|
||||
OPENSSL_assert(mpk->hashfcn);
|
||||
ASN1_OBJECT_free(mpk->hashfcn);
|
||||
if (!(mpk->hashfcn = OBJ_nid2obj(EVP_MD_type(md)))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, BFIBE_R_PARSE_PAIRING);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* set msk->version
|
||||
* random msk->masterSecret in [2, q - 1]
|
||||
*/
|
||||
|
||||
msk->version = BFIBE_VERSION;
|
||||
|
||||
do {
|
||||
if (!BN_rand_range(msk->masterSecret, mpk->q)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
} while (BN_is_zero(msk->masterSecret) || BN_is_one(msk->masterSecret));
|
||||
|
||||
/* mpk->pointPpub = msk->masterSecret * mpk->pointP */
|
||||
|
||||
if (!EC_POINT_mul(group, point, msk->masterSecret, NULL, NULL, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, point,
|
||||
mpk->pointPpub->x, mpk->pointPpub->y, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_SETUP, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* set return value */
|
||||
*pmpk = mpk;
|
||||
*pmsk = msk;
|
||||
ret = 1;
|
||||
|
||||
end:
|
||||
if (!ret) {
|
||||
BFPublicParameters_free(mpk);
|
||||
BFMasterSecret_free(msk);
|
||||
*pmpk = NULL;
|
||||
*pmsk = NULL;
|
||||
}
|
||||
if (bn_ctx) {
|
||||
BN_CTX_end(bn_ctx);
|
||||
}
|
||||
BN_CTX_free(bn_ctx);
|
||||
EC_POINT_free(point);
|
||||
return ret;
|
||||
}
|
||||
|
||||
BFPrivateKeyBlock *BFIBE_extract_private_key(BFPublicParameters *mpk,
|
||||
BFMasterSecret *msk, const char *id, size_t idlen)
|
||||
{
|
||||
int e = 1;
|
||||
BFPrivateKeyBlock *ret = NULL;
|
||||
EC_GROUP *group = NULL;
|
||||
EC_POINT *point = NULL;
|
||||
BN_CTX *bn_ctx = NULL;
|
||||
const EVP_MD *md;
|
||||
|
||||
if (!mpk || !msk || !id || idlen <= 0) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!(bn_ctx = BN_CTX_new())) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY,
|
||||
ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* get EC_GROUP from mpk->{p, q, pointP}
|
||||
* get EVP_MD from mpk->hashfcn
|
||||
*/
|
||||
if (!(group = EC_GROUP_new_type1curve(mpk->p, mpk->pointP->x,
|
||||
mpk->pointP->y, mpk->q, bn_ctx))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY, BFIBE_R_PARSE_CURVE_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(md = EVP_get_digestbyobj(mpk->hashfcn))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY,
|
||||
BFIBE_R_INVALID_BFIBE_HASHFUNC);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* prepare tmp variables */
|
||||
point = EC_POINT_new(group);
|
||||
if (!point) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* set ret->version
|
||||
* set ret->privateKey = msk->masterSecret * HashToPoint(ID)
|
||||
*/
|
||||
|
||||
if (!(ret = BFPrivateKeyBlock_new())) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ret->version = BFIBE_VERSION;
|
||||
|
||||
if (!EC_POINT_hash2point(group, md, id, idlen, point, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_POINT_mul(group, point, NULL, point, msk->masterSecret, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, point,
|
||||
ret->privateKey->x, ret->privateKey->y, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_EXTRACT_PRIVATE_KEY, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
e = 0;
|
||||
end:
|
||||
if (e && ret) {
|
||||
BFPrivateKeyBlock_free(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
EC_GROUP_free(group);
|
||||
EC_POINT_free(point);
|
||||
BN_CTX_free(bn_ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* r = rand(), |r| = hashlen
|
||||
* k = HashToRange(r||Hash(m), q), k in [0, q-1]
|
||||
* U = [k]P in E/F_p
|
||||
* Q = HashToPoint(ID) in E/F_p
|
||||
* v = Hash(e(Ppub, Q)^k) xor r, |v| == hashlen
|
||||
* w = HashBytes(r) xor m
|
||||
*/
|
||||
BFCiphertextBlock *BFIBE_do_encrypt(BFPublicParameters *mpk,
|
||||
const unsigned char *in, size_t inlen,
|
||||
const char *id, size_t idlen)
|
||||
{
|
||||
int e = 1;
|
||||
BFCiphertextBlock *ret = NULL;
|
||||
BN_CTX *bn_ctx = NULL;
|
||||
EC_GROUP *group = NULL;
|
||||
EC_POINT *Ppub = NULL;
|
||||
EC_POINT *point = NULL;
|
||||
BN_GFP2 *theta = NULL;
|
||||
BIGNUM *k;
|
||||
const EVP_MD *md;
|
||||
KDF_FUNC hash_bytes;
|
||||
unsigned char rho[EVP_MAX_MD_SIZE * 2];
|
||||
unsigned char buf[EVP_MAX_MD_SIZE];
|
||||
unsigned int len;
|
||||
size_t size;
|
||||
int i;
|
||||
|
||||
if (!mpk || !in || inlen <= 0 || !id || idlen <= 0) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* BN_CTX */
|
||||
if (!(bn_ctx = BN_CTX_new())) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
BN_CTX_start(bn_ctx);
|
||||
|
||||
/* EC_GROUP */
|
||||
if (!(group = EC_GROUP_new_type1curve(mpk->p, mpk->pointP->x,
|
||||
mpk->pointP->y, mpk->q, bn_ctx))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, BFIBE_R_PARSE_MPK_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = BFCiphertextBlock_new();
|
||||
Ppub = EC_POINT_new(group);
|
||||
point = EC_POINT_new(group);
|
||||
theta = BN_GFP2_new();
|
||||
k = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!ret || !point || !Ppub || !k || !theta) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
|
||||
/* get kdf from mpk->hashfcn */
|
||||
if (!(md = EVP_get_digestbyobj(mpk->hashfcn))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, BFIBE_R_INVALID_BFIBE_HASHFUNC);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(hash_bytes = KDF_get_ibcs(md))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT,
|
||||
BFIBE_R_INVALID_BFIBE_HASHFUNC);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* ret->version */
|
||||
ret->version = BFIBE_VERSION;
|
||||
|
||||
/* rho = Rand(hashlen) */
|
||||
if (!RAND_bytes(rho, EVP_MD_size(md))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, BFIBE_R_RAND_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* k = HashToRange(rho||Hash(in), q) in [0, q - 1] */
|
||||
len = EVP_MD_size(md);
|
||||
if (!EVP_Digest(in, inlen, rho + EVP_MD_size(md), &len, md, NULL)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EVP_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_hash_to_range(md, &k, rho, EVP_MD_size(md) * 2, mpk->q, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* ret->u = mpk->pointP * k in E/F_p, mpk->pointP is the generator */
|
||||
if (!EC_POINT_mul(group, point, k, NULL, NULL, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, point,
|
||||
ret->u->x, ret->u->y, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* theta = e(mpk->pointPpub, HashToPoint(ID)) */
|
||||
if (!EC_POINT_set_affine_coordinates_GFp(group, Ppub,
|
||||
mpk->pointPpub->x, mpk->pointPpub->y, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_POINT_hash2point(group, md, id, idlen, point, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_type1curve_tate(group, theta, Ppub, point, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* theta = theta^k */
|
||||
if (!BN_GFP2_exp(theta, theta, k, mpk->p, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* ret->v = Hash(theta) xor rho */
|
||||
size = sizeof(buf);
|
||||
if (!BN_GFP2_canonical(theta, buf, &size, 0, mpk->p, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
len = sizeof(buf);
|
||||
if (!EVP_Digest(buf, size, buf, &len, md, NULL)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_EVP_LIB);
|
||||
goto end;
|
||||
}
|
||||
for (i = 0; i < EVP_MD_size(md); i++) {
|
||||
buf[i] ^= rho[i];
|
||||
}
|
||||
if (!ASN1_OCTET_STRING_set(ret->v, buf, EVP_MD_size(md))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_ASN1_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* ret->w = HashBytes(rho) xor m */
|
||||
if (!ASN1_OCTET_STRING_set(ret->w, NULL, inlen)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
size = inlen;
|
||||
if (!hash_bytes(rho, EVP_MD_size(md), ret->w->data, &size)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_ENCRYPT,
|
||||
BFIBE_R_HASH_BYTES_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
for (i = 0; i < inlen; i++) {
|
||||
ret->w->data[i] ^= in[i];
|
||||
}
|
||||
|
||||
e = 0;
|
||||
|
||||
end:
|
||||
if (e && ret) {
|
||||
BFCiphertextBlock_free(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
if (bn_ctx) {
|
||||
BN_CTX_end(bn_ctx);
|
||||
}
|
||||
BN_CTX_free(bn_ctx);
|
||||
EC_GROUP_free(group);
|
||||
EC_POINT_free(Ppub);
|
||||
EC_POINT_free(point);
|
||||
BN_GFP2_free(theta);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int BFIBE_do_decrypt(BFPublicParameters *mpk,
|
||||
const BFCiphertextBlock *in, unsigned char *out, size_t *outlen,
|
||||
BFPrivateKeyBlock *sk)
|
||||
{
|
||||
int ret = 0;
|
||||
BN_CTX *bn_ctx = NULL;
|
||||
EC_GROUP *group = NULL;
|
||||
EC_POINT *point = NULL;
|
||||
EC_POINT *point1 = NULL;
|
||||
BN_GFP2 *theta = NULL;
|
||||
BIGNUM *k;
|
||||
const EVP_MD *md;
|
||||
KDF_FUNC hash_bytes;
|
||||
unsigned char rho[EVP_MAX_MD_SIZE * 2];
|
||||
size_t size;
|
||||
unsigned int len;
|
||||
int i;
|
||||
|
||||
if (!mpk || !in || !outlen || !sk) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!out) {
|
||||
*outlen = in->w->length;
|
||||
return 1;
|
||||
}
|
||||
if (*outlen < in->w->length) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT,
|
||||
BFIBE_R_BUFFER_TOO_SMALL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* BN_CTX */
|
||||
if (!(bn_ctx = BN_CTX_new())) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
BN_CTX_start(bn_ctx);
|
||||
|
||||
/* EC_GROUP */
|
||||
if (!(group = EC_GROUP_new_type1curve(mpk->p, mpk->pointP->x,
|
||||
mpk->pointP->y, mpk->q, bn_ctx))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT,
|
||||
BFIBE_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
point = EC_POINT_new(group);
|
||||
point1 = EC_POINT_new(group);
|
||||
theta = BN_GFP2_new();
|
||||
k = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!point || !point1 || !theta || !k) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* theta = e(ciphertext->u, sk->privateKey) */
|
||||
if (!EC_POINT_set_affine_coordinates_GFp(group, point,
|
||||
in->u->x, in->u->y, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_POINT_set_affine_coordinates_GFp(group, point1,
|
||||
sk->privateKey->x, sk->privateKey->y, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_type1curve_tate(group, theta, point, point1, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* md = mpk->hashfcn */
|
||||
if (!(md = EVP_get_digestbyobj(mpk->hashfcn))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, BFIBE_R_INVALID_BFIBE_HASHFUNC);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* rho = Hash(Canoncial(theta)) xor ciphertext->v */
|
||||
size = sizeof(rho);
|
||||
if (!BN_GFP2_canonical(theta, rho, &size, 0, mpk->p, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
len = size;
|
||||
if (!EVP_Digest(rho, size, rho, &len, md, NULL)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_EVP_LIB);
|
||||
goto end;
|
||||
}
|
||||
for (i = 0; i < EVP_MD_size(md); i++) {
|
||||
rho[i] ^= in->v->data[i];
|
||||
}
|
||||
|
||||
/* function hash_bytes() = kdf(md) */
|
||||
if (!(hash_bytes = KDF_get_ibcs(md))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT,
|
||||
BFIBE_R_INVALID_BFIBE_HASHFUNC);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* out = HashBytes(rho) xor ciphertext->w */
|
||||
size = in->w->length;
|
||||
if (!hash_bytes(rho, EVP_MD_size(md), out, &size)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT,
|
||||
BFIBE_R_KDF_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
for (i = 0; i < in->w->length; i++) {
|
||||
out[i] ^= in->w->data[i];
|
||||
}
|
||||
|
||||
/* k = HashToRange(rho || Hash(out)) in [0, mpk->q) */
|
||||
len = EVP_MD_size(md);
|
||||
if (!EVP_Digest(out, in->w->length, rho + EVP_MD_size(md), &len, md, NULL)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_EVP_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_hash_to_range(md, &k, rho, EVP_MD_size(md) * 2, mpk->q, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* Verify that in->u == mpk->pointP * k */
|
||||
if (!EC_POINT_mul(group, point, k, NULL, NULL, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (1 != EC_POINT_cmp_fppoint(group, point, in->u, bn_ctx)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DO_DECRYPT, BFIBE_R_BFIBE_CIPHERTEXT_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
*outlen = in->w->length;
|
||||
ret = 1;
|
||||
|
||||
end:
|
||||
if (bn_ctx) {
|
||||
BN_CTX_end(bn_ctx);
|
||||
}
|
||||
BN_CTX_free(bn_ctx);
|
||||
EC_GROUP_free(group);
|
||||
EC_POINT_free(point);
|
||||
EC_POINT_free(point1);
|
||||
BN_GFP2_free(theta);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* estimation of the max length of DER encoded ciphertext */
|
||||
static int BFCiphertextBlock_size(BFPublicParameters *mpk,
|
||||
size_t inlen, size_t *outlen)
|
||||
{
|
||||
size_t len = 0;
|
||||
len += (OPENSSL_ECC_MAX_FIELD_BITS/8) * 2;
|
||||
len += inlen;
|
||||
len += EVP_MAX_MD_SIZE;
|
||||
len += 128; /* caused by version and DER encoding */
|
||||
*outlen = len;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int BFIBE_encrypt(BFPublicParameters *mpk,
|
||||
const unsigned char *in, size_t inlen,
|
||||
unsigned char *out, size_t *outlen,
|
||||
const char *id, size_t idlen)
|
||||
{
|
||||
int ret = 0;
|
||||
BFCiphertextBlock *c = NULL;
|
||||
unsigned char *p;
|
||||
size_t len;
|
||||
|
||||
if (!mpk || !in || inlen <= 0 || !outlen || !id || idlen <= 0) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_ENCRYPT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!BFCiphertextBlock_size(mpk, inlen, &len)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_ENCRYPT, BFIBE_R_COMPUTE_OUTLEN_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
if (!out) {
|
||||
*outlen = len;
|
||||
return 1;
|
||||
}
|
||||
if (*outlen < len) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_ENCRYPT, BFIBE_R_BUFFER_TOO_SMALL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!(c = BFIBE_do_encrypt(mpk, in, inlen, id, idlen))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_ENCRYPT, BFIBE_R_ENCRYPT_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
p = out;
|
||||
if (!i2d_BFCiphertextBlock(c, &p)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_ENCRYPT, BFIBE_R_I2D_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
len = p - out;
|
||||
|
||||
*outlen = len;
|
||||
ret = 1;
|
||||
|
||||
end:
|
||||
BFCiphertextBlock_free(c);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int BFIBE_decrypt(BFPublicParameters *mpk,
|
||||
const unsigned char *in, size_t inlen,
|
||||
unsigned char *out, size_t *outlen,
|
||||
BFPrivateKeyBlock *sk)
|
||||
{
|
||||
int ret = 0;
|
||||
BFCiphertextBlock *c = NULL;
|
||||
const unsigned char *p;
|
||||
|
||||
if (!mpk || !in || inlen <= 0 || !outlen || !sk) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DECRYPT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!out) {
|
||||
*outlen = inlen;
|
||||
return 1;
|
||||
}
|
||||
if (*outlen < inlen) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DECRYPT, BFIBE_R_BUFFER_TOO_SMALL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
p = in;
|
||||
if (!(c = d2i_BFCiphertextBlock(NULL, &p, inlen))) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DECRYPT, BFIBE_R_D2I_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* check no remaining ciphertext */
|
||||
if (p - in != inlen) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DECRYPT, BFIBE_R_INVALID_CIPHERTEXT);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!BFIBE_do_decrypt(mpk, c, out, outlen, sk)) {
|
||||
BFIBEerr(BFIBE_F_BFIBE_DECRYPT, BFIBE_R_DECRYPT_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
BFCiphertextBlock_free(c);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=bfibe_err.c bfibe_asn1.c bfibe_lib.c
|
||||
@@ -6,7 +6,7 @@ SOURCE[../../libcrypto]=\
|
||||
ecp_nistp224.c ecp_nistp256.c ecp_nistp521.c ecp_nistputil.c \
|
||||
ecp_oct.c ec2_oct.c ec_oct.c ec_kmeth.c ecdh_ossl.c ecdh_kdf.c \
|
||||
ecdsa_ossl.c ecdsa_sign.c ecdsa_vrf.c curve25519.c ecx_meth.c \
|
||||
{- $target{ec_asm_src} -} ecahe.c
|
||||
{- $target{ec_asm_src} -}
|
||||
|
||||
GENERATE[ecp_nistz256-x86.s]=asm/ecp_nistz256-x86.pl $(PERLASM_SCHEME) $(CFLAGS) $(LIB_CFLAGS) $(PROCESSOR)
|
||||
|
||||
|
||||
@@ -1,456 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 - 2019 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/ecahe.h>
|
||||
|
||||
struct ECAHE_CIPHERTEXT_st {
|
||||
EC_POINT *A;
|
||||
EC_POINT *B;
|
||||
};
|
||||
|
||||
ASN1_SEQUENCE(ECAHE_CIPHERTEXT) = {
|
||||
ASN1_SIMPLE(ECAHE_CIPHERTEXT, A, ASN1_OCTET_STRING),
|
||||
ASN1_SIMPLE(ECAHE_CIPHERTEXT, B, ASN1_OCTET_STRING)
|
||||
} ASN1_SEQUENCE_END(ECAHE_CIPHERTEXT)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(ECAHE_CIPHERTEXT)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(ECAHE_CIPHERTEXT)
|
||||
|
||||
|
||||
#define EC_MAX_PLAINTEXT (65536)
|
||||
|
||||
|
||||
int ECAHE_ciphertext_size(EC_KEY *pk)
|
||||
{
|
||||
ECerr(EC_F_ECAHE_CIPHERTEXT_SIZE, ERR_R_EC_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ECAHE_encrypt(unsigned char *out, size_t *outlen, const BIGNUM *in, EC_KEY *pk)
|
||||
{
|
||||
ECerr(EC_F_ECAHE_ENCRYPT, ERR_R_EC_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ECAHE_decrypt(unsigned long *out, const unsigned char *in, size_t inlen, EC_KEY *sk)
|
||||
{
|
||||
ECerr(EC_F_ECAHE_DECRYPT, ERR_R_EC_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ECAHE_do_encrypt(ECAHE_CIPHERTEXT *c, const BIGNUM *m, EC_KEY *pk)
|
||||
{
|
||||
int ret = -1;
|
||||
const EC_GROUP *group;
|
||||
const EC_POINT *point;
|
||||
BIGNUM *order = NULL;
|
||||
BN_CTX *ctx = NULL;
|
||||
BIGNUM *r = NULL;
|
||||
|
||||
OPENSSL_assert(c);
|
||||
OPENSSL_assert(m);
|
||||
OPENSSL_assert(pk);
|
||||
|
||||
if (!(group = EC_KEY_get0_group(pk))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(order = BN_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(ctx = BN_CTX_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_GROUP_get_order(group, order, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(r = BN_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
do {
|
||||
if (!BN_rand_range(r, order)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
} while (BN_is_zero(r));
|
||||
|
||||
if (c->A == NULL) {
|
||||
if (!(c->A = EC_POINT_new(group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
/* c->A = [r]G */
|
||||
if (!EC_POINT_mul(group, c->A, r, NULL, NULL, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (c->B == NULL) {
|
||||
if (!(c->B = EC_POINT_new(group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
if (!(point = EC_KEY_get0_public_key(pk))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
{
|
||||
//EC_POINT *T = EC_POINT_new(group);
|
||||
//EC_POINT_mul(group, T, m, NULL, NULL, ctx);
|
||||
//printf("[m]G = %s\n", EC_POINT_point2hex(group, T, EC_PUBKEY_FORMAT, ctx));
|
||||
}
|
||||
|
||||
/* c->b = [m]G + [r]P */
|
||||
if (!EC_POINT_mul(group, c->B, m, point, r, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
|
||||
end:
|
||||
if (r) BN_free(r);
|
||||
if (order) BN_free(order);
|
||||
if (ctx) BN_CTX_free(ctx);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* A == [r]G
|
||||
* B == [m]G + [r]P == [m]G + [rd]G
|
||||
* B - [d]A == B - [rd]G == [m]G
|
||||
*/
|
||||
int ECAHE_do_decrypt(BIGNUM *m, const ECAHE_CIPHERTEXT *c, EC_KEY *sk)
|
||||
{
|
||||
int ret = -1;
|
||||
|
||||
const EC_GROUP *group;
|
||||
const EC_POINT *G;
|
||||
const BIGNUM *d;
|
||||
BN_CTX *ctx = NULL;
|
||||
BIGNUM *order = NULL;
|
||||
EC_POINT *point = NULL;
|
||||
EC_POINT *point2 = NULL;
|
||||
unsigned int i;
|
||||
|
||||
OPENSSL_assert(m);
|
||||
OPENSSL_assert(c && c->A && c->B);
|
||||
OPENSSL_assert(sk);
|
||||
|
||||
if (!(group = EC_KEY_get0_group(sk))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(G = EC_GROUP_get0_generator(group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(d = EC_KEY_get0_private_key(sk))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(ctx = BN_CTX_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(order = BN_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_GROUP_get_order(group, order, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(point = EC_POINT_new(group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!BN_one(order)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* point = [d]A = [rd]G */
|
||||
if (!EC_POINT_mul(group, point, NULL, c->A, d, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* point = -[rd]G */
|
||||
if (!EC_POINT_invert(group, point, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* point = B - [rd]G = [m]G + [rd]G - [rd]G = [m]G */
|
||||
if (!EC_POINT_add(group, point, point, c->B, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
{
|
||||
//printf("[m]G = %s\n", EC_POINT_point2hex(group, point, EC_PUBKEY_FORMAT, ctx));
|
||||
}
|
||||
|
||||
if (!(point2 = EC_POINT_new(group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_POINT_set_to_infinity(group, point2)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
for (i = 0; i < EC_MAX_PLAINTEXT; i++) {
|
||||
|
||||
//printf("%03d ", i);
|
||||
//printf(" %s\n", EC_POINT_point2hex(group, point, EC_PUBKEY_FORMAT, ctx));
|
||||
//printf(" %s\n", EC_POINT_point2hex(group, point2, EC_PUBKEY_FORMAT, ctx));
|
||||
|
||||
if (EC_POINT_cmp(group, point, point2, ctx) == 0) {
|
||||
if (!BN_set_word(m, i)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
goto end;
|
||||
}
|
||||
|
||||
//printf("SUCCESS: %d\n", i+1);
|
||||
ret = 0;
|
||||
goto end;
|
||||
}
|
||||
|
||||
EC_POINT_add(group, point2, point2, EC_GROUP_get0_generator(group), ctx);
|
||||
}
|
||||
|
||||
|
||||
end:
|
||||
if (ctx) BN_CTX_free(ctx);
|
||||
if (order) BN_free(order);
|
||||
if (point) EC_POINT_free(point);
|
||||
if (point2) EC_POINT_free(point2);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ECAHE_ciphertext_add(ECAHE_CIPHERTEXT *r,
|
||||
const ECAHE_CIPHERTEXT *a, const ECAHE_CIPHERTEXT *b,
|
||||
EC_KEY *pk)
|
||||
{
|
||||
const EC_GROUP *group = EC_KEY_get0_group(pk);
|
||||
BN_CTX *ctx = NULL;
|
||||
|
||||
if (!(group = EC_KEY_get0_group(pk))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
OPENSSL_assert(a->A);
|
||||
OPENSSL_assert(b->A);
|
||||
OPENSSL_assert(a->B);
|
||||
OPENSSL_assert(b->B);
|
||||
|
||||
if (r->A == NULL) {
|
||||
if (!(r->A = EC_POINT_new(group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (r->B == NULL) {
|
||||
if (!(r->B = EC_POINT_new(group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (!(ctx = BN_CTX_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
if (!EC_POINT_add(group, r->A, a->A, b->A, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
BN_CTX_free(ctx);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
if (!EC_POINT_add(group, r->B, a->B, b->B, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
BN_CTX_free(ctx);
|
||||
return -1;
|
||||
}
|
||||
|
||||
BN_CTX_free(ctx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ECAHE_ciphertext_sub(ECAHE_CIPHERTEXT *r,
|
||||
const ECAHE_CIPHERTEXT *a, const ECAHE_CIPHERTEXT *b,
|
||||
EC_KEY *pk)
|
||||
{
|
||||
const EC_GROUP *group = EC_KEY_get0_group(pk);
|
||||
BN_CTX *ctx = NULL;
|
||||
|
||||
if (!(group = EC_KEY_get0_group(pk))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
OPENSSL_assert(a->A);
|
||||
OPENSSL_assert(b->A);
|
||||
OPENSSL_assert(a->B);
|
||||
OPENSSL_assert(b->B);
|
||||
|
||||
if (ECAHE_ciphertext_neg(r, b, pk) < 0) {
|
||||
fprintf(stderr, "%s (%s %d): ec_ciphertext_neg failed\n",
|
||||
__FUNCTION__, __FILE__, __LINE__);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
if (!(ctx = BN_CTX_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
if (!EC_POINT_add(group, r->A, r->A, a->A, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
BN_CTX_free(ctx);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!EC_POINT_add(group, r->B, r->B, a->B, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
BN_CTX_free(ctx);
|
||||
return -1;
|
||||
}
|
||||
|
||||
BN_CTX_free(ctx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ECAHE_ciphertext_neg(ECAHE_CIPHERTEXT *r, const ECAHE_CIPHERTEXT *a,
|
||||
EC_KEY *pk)
|
||||
{
|
||||
const EC_GROUP *group;
|
||||
BN_CTX *ctx = NULL;
|
||||
|
||||
OPENSSL_assert(r && a && pk);
|
||||
OPENSSL_assert(a->A);
|
||||
OPENSSL_assert(a->B);
|
||||
|
||||
|
||||
if (!(group = EC_KEY_get0_group(pk))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
if (r->A)
|
||||
EC_POINT_free(r->A);
|
||||
if (!(r->A = EC_POINT_dup(a->A, group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (r->B)
|
||||
EC_POINT_free(r->B);
|
||||
if (!(r->B = EC_POINT_dup(a->B, group))) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (!(ctx = BN_CTX_new())) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
return -1;
|
||||
}
|
||||
if (!EC_POINT_invert(group, r->A, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
BN_CTX_free(ctx);
|
||||
return -1;
|
||||
}
|
||||
if (!EC_POINT_invert(group, r->B, ctx)) {
|
||||
ERR_print_errors_fp(stderr);
|
||||
BN_CTX_free(ctx);
|
||||
return -1;
|
||||
}
|
||||
|
||||
BN_CTX_free(ctx);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,490 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
/*
|
||||
* this file implement complex number over prime field
|
||||
* a = a0 + a1 * i, i^2 == -1
|
||||
* most of the routines should be replaced by macros
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
|
||||
/*
|
||||
* to make it simple, currently both a0 and a1 will be inited
|
||||
*/
|
||||
|
||||
BN_GFP2 *BN_GFP2_new(void)
|
||||
{
|
||||
int e = 1;
|
||||
BN_GFP2 *ret = NULL;
|
||||
|
||||
if (!(ret = OPENSSL_malloc(sizeof(BN_GFP2)))) {
|
||||
BNerr(BN_F_BN_GFP2_NEW, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ret->a0 = BN_new();
|
||||
ret->a1 = BN_new();
|
||||
if (!ret->a0 || !ret->a1) {
|
||||
BNerr(BN_F_BN_GFP2_NEW, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
BN_zero(ret->a0);
|
||||
BN_zero(ret->a1);
|
||||
|
||||
e = 0;
|
||||
end:
|
||||
if (e && ret) {
|
||||
BN_GFP2_free(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void BN_GFP2_free(BN_GFP2 *a)
|
||||
{
|
||||
if (a) {
|
||||
BN_free(a->a0);
|
||||
BN_free(a->a1);
|
||||
OPENSSL_free(a);
|
||||
}
|
||||
}
|
||||
|
||||
int BN_GFP2_copy(BN_GFP2 *r, const BN_GFP2 *a)
|
||||
{
|
||||
if (!r || !r->a0 || !r->a1 || !a || !a->a0 || !a->a1) {
|
||||
BNerr(BN_F_BN_GFP2_COPY, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!BN_copy(r->a0, a->a0)) {
|
||||
BNerr(BN_F_BN_GFP2_COPY, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
if (!BN_copy(r->a1, a->a1)) {
|
||||
BNerr(BN_F_BN_GFP2_COPY, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int BN_GFP2_one(BN_GFP2 *a)
|
||||
{
|
||||
if (!a || !a->a0 || !a->a1) {
|
||||
BNerr(BN_F_BN_GFP2_ONE, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_one(a->a0);
|
||||
BN_zero(a->a1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int BN_GFP2_zero(BN_GFP2 *a)
|
||||
{
|
||||
if (!a || !a->a0 || !a->a1) {
|
||||
BNerr(BN_F_BN_GFP2_ZERO, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_zero(a->a0);
|
||||
BN_zero(a->a1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* return 1 on success, so dont use !BN_GFP2_is_zero() to check return value */
|
||||
int BN_GFP2_is_zero(const BN_GFP2 *a)
|
||||
{
|
||||
if (!a || !a->a0 || !a->a1) {
|
||||
BNerr(BN_F_BN_GFP2_IS_ZERO, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return (BN_is_zero(a->a0) && BN_is_zero(a->a1));
|
||||
}
|
||||
|
||||
int BN_GFP2_equ(const BN_GFP2 *a, const BN_GFP2 *b)
|
||||
{
|
||||
if (!a || !b || !a->a0 || !a->a1 || !b->a0 || !b->a1) {
|
||||
BNerr(BN_F_BN_GFP2_EQU, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ((BN_cmp(a->a0, b->a0) == 0) && (BN_cmp(a->a1, b->a1) == 0));
|
||||
}
|
||||
|
||||
int BN_GFP2_add(BN_GFP2 *r, const BN_GFP2 *a, const BN_GFP2 *b,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
if (!a || !b || !a->a0 || !a->a1 || !b->a0 || !b->a1 || !p || !ctx) {
|
||||
BNerr(BN_F_BN_GFP2_ADD, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!BN_mod_add(r->a0, a->a0, b->a0, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_ADD, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
if (!BN_mod_add(r->a1, a->a1, b->a1, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_ADD, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int BN_GFP2_sub(BN_GFP2 *r, const BN_GFP2 *a, const BN_GFP2 *b,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
if (!a || !b || !a->a0 || !a->a1 || !b->a0 || !b->a1 || !p || !ctx) {
|
||||
BNerr(BN_F_BN_GFP2_SUB, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!BN_mod_sub(r->a0, a->a0, b->a0, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_SUB, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
if (!BN_mod_sub(r->a1, a->a1, b->a1, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_SUB, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* (a0 + a1 * i) * (b0 + b1 * i)
|
||||
* = a0 * b0 + a1 * b1 * i^2 + (a0 * b1 + a1 * b0) * i
|
||||
* = (a0 * b0 - a1 * b1) + (a0 * b1 + a1 * b0) * i
|
||||
*/
|
||||
int BN_GFP2_mul(BN_GFP2 *r, const BN_GFP2 *a, const BN_GFP2 *b,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *t = NULL;
|
||||
|
||||
BN_CTX_start(ctx);
|
||||
|
||||
if (!(t = BN_CTX_get(ctx))) {
|
||||
BNerr(BN_F_BN_GFP2_MUL, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* r->a0 = a->a0 * b->a0 - a->a1 * b->a1 (mod p) */
|
||||
if (!BN_mod_mul(r->a0, a->a0, b->a0, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_MUL, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(t, a->a1, b->a1, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_MUL, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_sub(r->a0, r->a0, t, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_MUL, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* r->a1 = a->a0 * b->a1 + a->a1 * b->a0 (mod p) */
|
||||
if (!BN_mod_mul(r->a1, a->a0, b->a1, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_MUL, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(t, a->a1, b->a0, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_MUL, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_add(r->a1, r->a1, t, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_MUL, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
BN_CTX_end(ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int BN_GFP2_sqr(BN_GFP2 *r, const BN_GFP2 *a,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
return BN_GFP2_mul(r, a, a, p, ctx);
|
||||
}
|
||||
|
||||
/*
|
||||
* (a0 + a1 * i) * (a0 - a1 * i)
|
||||
* = a0^2 - a1^2 * i^2
|
||||
* = a0^2 + a1^2
|
||||
* ==> (a0 + a1 * i) * (a0 - a1 * i) * (a0^2 + a1^2)^-1 == 1
|
||||
* ==> (a0 + a1 * i)^-1 == (a0 - a1 * i) * (a0^2 + a1^2)^-1
|
||||
*/
|
||||
int BN_GFP2_inv(BN_GFP2 *r, const BN_GFP2 *a, const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *t = NULL;
|
||||
|
||||
BN_CTX_start(ctx);
|
||||
|
||||
if (!(t = BN_CTX_get(ctx))) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* t = (a0^2 + a1^2)^-1 */
|
||||
if (!BN_mod_sqr(r->a0, a->a0, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_sqr(r->a1, a->a1, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(t, r->a0, r->a1, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_inverse(t, t, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* r0 = a0^ t (mod p) */
|
||||
if (!BN_mod_mul(r->a0, a->a0, t, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* r1 = p - a1^t (mod p) */
|
||||
if (!BN_mod_mul(r->a1, a->a1, t, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_sub(r->a1, p, r->a1)) {
|
||||
BNerr(BN_F_BN_GFP2_INV, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
BN_CTX_end(ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int BN_GFP2_div(BN_GFP2 *r, const BN_GFP2 *a, const BN_GFP2 *b, const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
if (!BN_GFP2_inv(r, b, p, ctx)) {
|
||||
return 0;
|
||||
}
|
||||
if (!BN_GFP2_mul(r, a, r, p, ctx)) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* need a fast implementation. check if k is solinas */
|
||||
int BN_GFP2_exp(BN_GFP2 *r, const BN_GFP2 *a, const BIGNUM *k, const BIGNUM *p,
|
||||
BN_CTX *ctx)
|
||||
{
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int BN_GFP2_set_bn(BN_GFP2 *r, const BIGNUM *a, const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
if (!r || !a || !p) {
|
||||
BNerr(BN_F_BN_GFP2_SET_BN, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
if (!BN_copy(r->a0, a)) {
|
||||
BNerr(BN_F_BN_GFP2_SET_BN, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
BN_zero(r->a1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int BN_GFP2_add_bn(BN_GFP2 *r, const BN_GFP2 *a, const BIGNUM *b,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
return BN_mod_add(r->a0, a->a0, b, p, ctx);
|
||||
}
|
||||
|
||||
int BN_GFP2_sub_bn(BN_GFP2 *r, const BN_GFP2 *a, const BIGNUM *b,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
return BN_mod_sub(r->a0, a->a0, b, p, ctx);
|
||||
}
|
||||
|
||||
int BN_GFP2_mul_bn(BN_GFP2 *r, const BN_GFP2 *a, const BIGNUM *b,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
return BN_mod_mul(r->a0, a->a0, b, p, ctx);
|
||||
}
|
||||
|
||||
int BN_GFP2_div_bn(BN_GFP2 *r, const BN_GFP2 *a, const BIGNUM *b,
|
||||
const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *binv;
|
||||
|
||||
if (!(binv = BN_CTX_get(ctx))) {
|
||||
BNerr(BN_F_BN_GFP2_DIV_BN, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_inverse(binv, b, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_DIV_BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(r->a0, a->a0, binv, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_DIV_BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(r->a1, a->a1, binv, p, ctx)) {
|
||||
BNerr(BN_F_BN_GFP2_DIV_BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
BN_CTX_end(ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int BN_bn2gfp2(const BIGNUM *bn, BN_GFP2 *gfp2, const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *a;
|
||||
|
||||
if (!(a = BN_CTX_get(ctx))) {
|
||||
goto end;
|
||||
}
|
||||
|
||||
BN_one(a);
|
||||
if (!BN_lshift(a, a, BN_num_bytes(p)*8)) {
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!BN_rshift(gfp2->a1, bn, BN_num_bytes(p)*8)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod(gfp2->a0, bn, a, ctx)) {
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
BN_CTX_end(ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* return (a0 + a1 << 2^n), n = log_2(p), n % 8 == 0 */
|
||||
int BN_gfp22bn(const BN_GFP2 *gfp2, BIGNUM *bn, const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
if (!BN_lshift(bn, gfp2->a1, BN_num_bytes(p) * 8)) {
|
||||
return 0;
|
||||
}
|
||||
if (!BN_add(bn, bn, gfp2->a0)) {
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int BN_GFP2_canonical(const BN_GFP2 *a, unsigned char *out, size_t *outlen,
|
||||
int order, const BIGNUM *p, BN_CTX *ctx)
|
||||
{
|
||||
size_t len;
|
||||
|
||||
if (!a || !a->a0 || !a->a1 || !outlen || !p) {
|
||||
BNerr(BN_F_BN_GFP2_CANONICAL, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
len = BN_num_bytes(p) * 2;
|
||||
if (!out) {
|
||||
*outlen = len;
|
||||
return 1;
|
||||
}
|
||||
if (*outlen < len) {
|
||||
BNerr(BN_F_BN_GFP2_CANONICAL, BN_R_BUFFER_TOO_SMALL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
memset(out, 0, len);
|
||||
if (order == 0) {
|
||||
/* low order first output (a0, a1) */
|
||||
if (!BN_bn2bin(a->a0, out + len/2 - BN_num_bytes(a->a0))) {
|
||||
BNerr(BN_F_BN_GFP2_CANONICAL, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
if (!BN_bn2bin(a->a1, out + len - BN_num_bytes(a->a1))) {
|
||||
BNerr(BN_F_BN_GFP2_CANONICAL, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
/* high order first output (a1, a0) */
|
||||
if (!BN_bn2bin(a->a1, out + len/2 - BN_num_bytes(a->a1))) {
|
||||
BNerr(BN_F_BN_GFP2_CANONICAL, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
if (!BN_bn2bin(a->a0, out + len - BN_num_bytes(a->a0))) {
|
||||
BNerr(BN_F_BN_GFP2_CANONICAL, ERR_R_BN_LIB);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
*outlen = len;
|
||||
return 1;
|
||||
}
|
||||
@@ -1,137 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/bn.h>
|
||||
#include "../bn/bn_lcl.h"
|
||||
|
||||
int BN_hash_to_range(const EVP_MD *md, BIGNUM **bn,
|
||||
const void *s, size_t slen, const BIGNUM *range, BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *r = NULL;
|
||||
BIGNUM *a = NULL;
|
||||
unsigned char *buf = NULL;
|
||||
size_t buflen, mdlen;
|
||||
int nbytes, rounds, i;
|
||||
|
||||
if (!s || slen <= 0 || !md || !range) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!(*bn)) {
|
||||
if (!(r = BN_new())) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
r = *bn;
|
||||
BN_zero(r);
|
||||
}
|
||||
|
||||
mdlen = EVP_MD_size(md);
|
||||
buflen = mdlen + slen;
|
||||
if (!(buf = OPENSSL_malloc(buflen))) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
memset(buf, 0, mdlen);
|
||||
memcpy(buf + mdlen, s, slen);
|
||||
|
||||
a = BN_new();
|
||||
if (!a) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
nbytes = BN_num_bytes(range);
|
||||
rounds = (nbytes + mdlen - 1)/mdlen;
|
||||
|
||||
if (!bn_expand(r, rounds * mdlen * 8)) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
for (i = 0; i < rounds; i++) {
|
||||
if (!EVP_Digest(buf, buflen, buf, (unsigned int *)&mdlen, md, NULL)) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_EVP_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_bin2bn(buf, mdlen, a)) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_lshift(r, r, mdlen * 8)) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_uadd(r, r, a)) {
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
if (!BN_mod(r, r, range, bn_ctx)) {
|
||||
BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
*bn = r;
|
||||
ret = 1;
|
||||
end:
|
||||
if (!ret && !(*bn)) {
|
||||
BN_free(r);
|
||||
}
|
||||
BN_free(a);
|
||||
OPENSSL_free(buf);
|
||||
return ret;
|
||||
}
|
||||
@@ -1,218 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/bn_solinas.h>
|
||||
#include "../bn/bn_lcl.h"
|
||||
|
||||
/*
|
||||
* generate the solinas prime tables,
|
||||
* use it for fast check of solinas
|
||||
*/
|
||||
|
||||
#define BN_SOLINAS_192V1 0
|
||||
#define BN_SOLINAS_192V2 1
|
||||
#define BN_SOLINAS_224V1 2
|
||||
#define BN_SOLINAS_256V1 3
|
||||
#define BN_SOLINAS_384V1 4
|
||||
#define BN_SOLINAS_512V1 5
|
||||
#define BN_SOLINAS_512V2 6
|
||||
#define BN_SOLINAS_1024V1 7
|
||||
#define BN_SOLINAS_1024V2 8
|
||||
|
||||
#if 0
|
||||
//remove warnings
|
||||
static BN_SOLINAS BN_solinas_table[] = {
|
||||
{ 192, 16, -1, -1 },
|
||||
{ 192, 64, -1, -1 },
|
||||
{ 224, 96, -1, 1 },
|
||||
{ 256, 168, -1, 1 },
|
||||
{ 384, 80, -1, 1 },
|
||||
{ 512, 32, -1, 1 },
|
||||
{ 512, 32, -1, -1 },
|
||||
{ 1024, 424, -1, -1 },
|
||||
{ 1024, 856, -1, 1 },
|
||||
};
|
||||
#endif
|
||||
|
||||
/*
|
||||
* solinas = 2^a + s * 2^b + c, where s, c in {1, -1}
|
||||
* solinas looks like:
|
||||
* 2^a + 2^b + 1 = 10000100001
|
||||
* 2^a - 2^b + 1 = 1111100001
|
||||
* 2^a + 2^b - 1 = 10000011111
|
||||
* 2^a - 2^b - 1 = 1111011111
|
||||
* so:
|
||||
* n = len(bits(solinas))
|
||||
* c = bits(solinas)[1] == 0 ? 1 : -1
|
||||
* s = bits(solinas)[n-2] == 0 ? 1 : -1
|
||||
* a = bits(solinas)[n-2] == 0 ? n-1 : n-2
|
||||
* b = len(bits(solinas - 2^a - s*2^b - c)) - 1
|
||||
*
|
||||
* examples:
|
||||
* 0xfffffffffffffffffffffffffffbffff
|
||||
* 0xffffffffffffffffffffffeffffffffffff
|
||||
* 0xfffffffffbfffffffffffffffffffffffff
|
||||
*/
|
||||
|
||||
int BN_bn2solinas(const BIGNUM *bn, BN_SOLINAS *solinas)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *tmp = NULL;
|
||||
int nbits;
|
||||
int i;
|
||||
|
||||
if (!solinas || !bn) {
|
||||
BNerr(BN_F_BN_BN2SOLINAS, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!BN_copy(tmp, bn)) {
|
||||
goto end;
|
||||
}
|
||||
|
||||
if ((nbits = BN_num_bits(bn) - 1) < 1) {
|
||||
BNerr(BN_F_BN_BN2SOLINAS, BN_R_INVALID_SOLINAS);
|
||||
goto end;
|
||||
}
|
||||
|
||||
solinas->c = BN_is_bit_set(bn, 1) ? 1 : -1;
|
||||
|
||||
if (BN_is_bit_set(bn, nbits - 1)) {
|
||||
solinas->s = -1;
|
||||
solinas->a = nbits;
|
||||
} else {
|
||||
solinas->s = 1;
|
||||
solinas->a = nbits - 1;
|
||||
}
|
||||
|
||||
for (i = 1; i < nbits; i++) {
|
||||
}
|
||||
|
||||
end:
|
||||
return ret;
|
||||
}
|
||||
|
||||
int BN_solinas2bn(const BN_SOLINAS *solinas, BIGNUM *bn)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *tmp = NULL;
|
||||
|
||||
if (!solinas || !bn) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (solinas->b <= 0 || solinas->a <= solinas->b
|
||||
|| (solinas->s != 1 && solinas->s != -1)
|
||||
|| (solinas->c != 1 && solinas->c != -1)) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, BN_R_INVALID_SOLINAS_PARAMETERS);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!(tmp = BN_new())) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
BN_one(tmp);
|
||||
|
||||
if (!BN_lshift(bn, tmp, solinas->a)) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!BN_lshift(tmp, tmp, solinas->b)) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!BN_add_word(tmp, solinas->c)) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (solinas->s > 0) {
|
||||
if (!BN_add(bn, bn, tmp)) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
} else {
|
||||
if (!BN_sub(bn, bn, tmp)) {
|
||||
BNerr(BN_F_BN_SOLINAS2BN, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
/* check if it is a prime */
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
BN_free(tmp);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int BN_generate_solinas(BIGNUM *ret, BN_SOLINAS *solinas, BN_GENCB *cb)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int BN_is_solinas(const BIGNUM *a)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_SOLINAS *BN_get_solinas(int index)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=bn_gfp2.c bn_solinas.c bn_hash.c \
|
||||
fppoint.c ec_hash.c ec_type1.c
|
||||
@@ -1,181 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/ec.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/objects.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
|
||||
/* currently the EC_POINT_hash2point only support type1curve! */
|
||||
int EC_POINT_hash2point(const EC_GROUP *group, const EVP_MD *md,
|
||||
const char *s, size_t slen, EC_POINT *point, BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *p = NULL;
|
||||
BIGNUM *x = NULL;
|
||||
BIGNUM *y = NULL;
|
||||
BIGNUM *k = NULL;
|
||||
BIGNUM *q = NULL;
|
||||
|
||||
if (!group || !md || !point || !s || slen <= 0 || !bn_ctx) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) != NID_X9_62_prime_field) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, EC_R_INVALID_CURVE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
p = BN_new();
|
||||
x = BN_new();
|
||||
y = BN_new();
|
||||
k = BN_new();
|
||||
q = BN_new();
|
||||
|
||||
if (!p || !x || !y || !k || !q) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_GROUP_get_curve_GFp(group, p, x, y, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* check group is type-1 curve */
|
||||
if (!BN_is_zero(x) || !BN_is_one(y) || BN_mod_word(p, 12) != 11) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, EC_R_INVALID_CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* get order */
|
||||
if (!EC_GROUP_get_order(group, q, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* y = HashToRange(s) in [0, p - 1] */
|
||||
if (!BN_hash_to_range(md, &y, s, slen, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* x = (y + 1) * (y - 1) mod p */
|
||||
if (!BN_copy(x, y)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_copy(k, y)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_add_word(x, 1)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_sub_word(k, 1)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(x, x, k, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* k = (p^2 - 1)/3 */
|
||||
if (!BN_lshift1(k, p)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_sub_word(k, 1)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_div_word(k, 3)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* compute x and point = (x, y) */
|
||||
if (!BN_mod_exp(x, x, k, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_POINT_set_affine_coordinates_GFp(group, point, x, y, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* compute [(p + 1)/q] * point */
|
||||
if (!BN_add_word(p, 1)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_div(k, NULL, p, q, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_POINT_mul(group, point, NULL, point, k, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_HASH2POINT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
BN_free(p);
|
||||
BN_free(x);
|
||||
BN_free(y);
|
||||
BN_free(k);
|
||||
BN_free(q);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -1,817 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*
|
||||
*/
|
||||
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/ec.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
|
||||
|
||||
EC_GROUP *EC_GROUP_generate_type1curve(const BIGNUM *order, BN_CTX *bn_ctx)
|
||||
{
|
||||
ECerr(EC_F_EC_GROUP_GENERATE_TYPE1CURVE, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
EC_GROUP *EC_GROUP_new_type1curve_ex(const BIGNUM *p, const BIGNUM *a,
|
||||
const BIGNUM *b, const unsigned char *point, size_t pointlen,
|
||||
const BIGNUM *order, const BIGNUM *cofactor, BN_CTX *bn_ctx)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
EC_GROUP *EC_GROUP_new_type1curve(const BIGNUM *p,
|
||||
const BIGNUM *x, const BIGNUM *y, const BIGNUM *order, BN_CTX *bn_ctx)
|
||||
{
|
||||
int e = 1;
|
||||
EC_GROUP *ret = NULL;
|
||||
BIGNUM *a = NULL;
|
||||
BIGNUM *b = NULL;
|
||||
EC_POINT *point = NULL;
|
||||
|
||||
if (!p || !x || !y || !order) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* check p = 11 (mod 12) */
|
||||
if (BN_mod_word(p, 12) != 11) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, EC_R_INVALID_TYPE1CURVE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
a = BN_CTX_get(bn_ctx);
|
||||
b = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!a || !b) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
BN_zero(a);
|
||||
BN_one(b);
|
||||
|
||||
if (!(ret = EC_GROUP_new_curve_GFp(p, a, b, bn_ctx))) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, EC_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* prepare generator point from (x, y) */
|
||||
if (!(point = EC_POINT_new(ret))) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_POINT_set_affine_coordinates_GFp(ret, point, x, y, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, EC_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* calculate cofactor h = (p + 1)/n
|
||||
* check n|(p + 1) where n is the order
|
||||
*/
|
||||
if (!BN_copy(a, p)) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_add_word(a, 1)) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
/* check (p + 1)%n == 0 */
|
||||
if (!BN_div(a, b, a, order, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_is_zero(b)) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, EC_R_INVLID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* set order and cofactor */
|
||||
if (!EC_GROUP_set_generator(ret, point, order, a)) {
|
||||
ECerr(EC_F_EC_GROUP_NEW_TYPE1CURVE, EC_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
e = 0;
|
||||
|
||||
end:
|
||||
if (e && ret) {
|
||||
EC_GROUP_free(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
BN_CTX_end(bn_ctx);
|
||||
EC_POINT_free(point);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int EC_GROUP_is_type1curve(const EC_GROUP *group, BN_CTX *bn_ctx)
|
||||
{
|
||||
ECerr(EC_F_EC_GROUP_IS_TYPE1CURVE, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* zeta = F_p((p-1)/2) + ((F_p(3)^((p + 1)/4))/2) * i, in F_p^2
|
||||
* which is used in phi() mapping in tate pairing over type1 curve
|
||||
*/
|
||||
BN_GFP2 *EC_GROUP_get_type1curve_zeta(const EC_GROUP *group, BN_CTX *bn_ctx)
|
||||
{
|
||||
int e = 1;
|
||||
BN_GFP2 *ret = NULL;
|
||||
BIGNUM *a = NULL;
|
||||
BIGNUM *b = NULL;
|
||||
BIGNUM *p = NULL;
|
||||
|
||||
if (!group || !bn_ctx) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
|
||||
ret = BN_GFP2_new();
|
||||
a = BN_CTX_get(bn_ctx);
|
||||
b = BN_CTX_get(bn_ctx);
|
||||
p = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!ret || !a || !b || !p) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* get curve p, a, b and check it is type1 curve
|
||||
* p is prime at least 512 bits, a == 0 and b == 1
|
||||
*/
|
||||
if (!EC_GROUP_get_curve_GFp(group, a, b, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_is_zero(a) || !BN_is_one(b)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, EC_R_INVALID_TYPE1_CURVE);
|
||||
goto end;
|
||||
}
|
||||
if (BN_num_bits(p) < 512) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, EC_R_INVALID_TYPE1_CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* set ret->a0 = (p - 1)/2
|
||||
*/
|
||||
if (!BN_copy(ret->a0, p)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_sub_word(ret->a0, 1)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
/* BN_div_word() return remainder, while (p - 1)%2 == 0 */
|
||||
if (BN_div_word(ret->a0, 2)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, EC_R_INVALID_TYPE1_CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* ret->a1 = (p + 1)/4, (ret->a1 + 1)%4 == 0
|
||||
*/
|
||||
if (!BN_copy(ret->a1, p)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_add_word(ret->a1, 1)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (BN_div_word(ret->a1, 4)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, EC_R_INVALID_TYPE1_CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* re-use a as 3
|
||||
* ret->a1 = 3^(ret->a1) mod p = 3^((p + 1)/4) mod p
|
||||
*/
|
||||
if (!BN_set_word(a, 3)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_exp(ret->a1, a, ret->a1, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* re-use b as 1/2 mod p
|
||||
* ret->a1 = ret->a1 / 2 mod p = (3^((p + 1)/4)) mod p
|
||||
*/
|
||||
if (!BN_set_word(b, 2)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_inverse(b, b, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(ret->a1, ret->a1, b, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ZETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
e = 0;
|
||||
end:
|
||||
if (e && ret) {
|
||||
BN_GFP2_free(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
BN_CTX_end(bn_ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* eta = (p^2 - 1)/n
|
||||
* which is used in the final modular exponentiation of tate pairing over
|
||||
* type1 curve
|
||||
*/
|
||||
BIGNUM *EC_GROUP_get_type1curve_eta(const EC_GROUP *group, BN_CTX *bn_ctx)
|
||||
{
|
||||
int e = 1;
|
||||
BIGNUM *ret = NULL;
|
||||
BIGNUM *a = NULL;
|
||||
BIGNUM *b = NULL;
|
||||
BIGNUM *p = NULL;
|
||||
|
||||
if (!group || !bn_ctx) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
|
||||
ret = BN_new();
|
||||
a = BN_CTX_get(bn_ctx);
|
||||
b = BN_CTX_get(bn_ctx);
|
||||
p = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!ret || !a || !b || !p) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* get curve p, a, b and check it is type1 curve
|
||||
* p is prime at least 512 bits, a == 0 and b == 1
|
||||
*/
|
||||
if (!EC_GROUP_get_curve_GFp(group, a, b, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_is_zero(a) || !BN_is_one(b)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, EC_R_INVALID_TYPE1_CURVE);
|
||||
goto end;
|
||||
}
|
||||
if (BN_num_bits(p) < 512) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, EC_R_INVALID_TYPE1_CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* get curve order n, re-use a for order n */
|
||||
if (!EC_GROUP_get_order(group, a, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/*
|
||||
* eta = (p^2 - 1)/n,
|
||||
*/
|
||||
if (!BN_sqr(ret, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_sub_word(ret, 1)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_div(ret, NULL, ret, a, bn_ctx)) {
|
||||
ECerr(EC_F_EC_GROUP_GET_TYPE1CURVE_ETA, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
e = 1;
|
||||
end:
|
||||
if (e && ret) {
|
||||
BN_free(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
BN_CTX_end(bn_ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* phi: (x, y) => (zeta * x, y) */
|
||||
static int type1curve_phi(const EC_GROUP *group, const EC_POINT *point,
|
||||
BN_GFP2 *x, BN_GFP2 *y, const BIGNUM *p, BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BN_GFP2 *zeta = NULL;
|
||||
BIGNUM *xP;
|
||||
BIGNUM *yP;
|
||||
|
||||
if (!group || !point || !x || !y || !p || !bn_ctx) {
|
||||
ECerr(EC_F_TYPE1CURVE_PHI,
|
||||
ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
xP = BN_CTX_get(bn_ctx);
|
||||
yP = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!xP || !yP) {
|
||||
ECerr(EC_F_TYPE1CURVE_PHI, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!(zeta = EC_GROUP_get_type1curve_zeta(group, bn_ctx))) {
|
||||
ECerr(EC_F_TYPE1CURVE_PHI,
|
||||
EC_R_GET_TYPE1CURVE_ZETA_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, point, xP, yP, bn_ctx))
|
||||
{
|
||||
ECerr(EC_F_TYPE1CURVE_PHI, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* return x = zeta * point->x */
|
||||
if (!BN_GFP2_mul_bn(x, zeta, xP, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_PHI, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* return y = point->y */
|
||||
if (!BN_GFP2_set_bn(y, yP, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_PHI, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
|
||||
end:
|
||||
BN_CTX_end(bn_ctx);
|
||||
BN_GFP2_free(zeta);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* eval the function defined by the line through point T and P,
|
||||
* with value Q = (xQ, yQ)
|
||||
*/
|
||||
static int type1curve_eval_line_textbook(const EC_GROUP *group, BN_GFP2 *r,
|
||||
const EC_POINT *T, const EC_POINT *P, const BN_GFP2 *xQ, const BN_GFP2
|
||||
*yQ,
|
||||
BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BN_GFP2 *num = NULL;
|
||||
BN_GFP2 *den = NULL;
|
||||
BIGNUM *p;
|
||||
BIGNUM *xT;
|
||||
BIGNUM *yT;
|
||||
BIGNUM *xP;
|
||||
BIGNUM *yP;
|
||||
BIGNUM *bn;
|
||||
BIGNUM *slope;
|
||||
|
||||
if (!group || !r || !T || !P || !xQ || !yQ || !bn_ctx) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
p = BN_CTX_get(bn_ctx);
|
||||
xT = BN_CTX_get(bn_ctx);
|
||||
yT = BN_CTX_get(bn_ctx);
|
||||
xP = BN_CTX_get(bn_ctx);
|
||||
yP = BN_CTX_get(bn_ctx);
|
||||
bn = BN_CTX_get(bn_ctx);
|
||||
slope = BN_CTX_get(bn_ctx);
|
||||
|
||||
num = BN_GFP2_new();
|
||||
den = BN_GFP2_new();
|
||||
|
||||
if (!p || !xT || !yT || !xP || !yP || !bn || !slope || !num || !den) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* get prime field p */
|
||||
if (!EC_GROUP_get_curve_GFp(group, p, xT, yT, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* get T and P */
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, T, xT, yT, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, P, xP, yP, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
#if 0
|
||||
/* if T == P, slope = (3 * x_T^2 + a)/(2 * y_T) */
|
||||
if (T == P || (BN_cmp(xT, xP) == 0 && BN_cmp(yT, yP) == 0)) {
|
||||
|
||||
if (!BN_mod_sqr(bn, xT, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_add(slope, bn, bn, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_add(slope, slope, bn, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_add(den, yT, yT, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_inverse(den, den, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(slope, slope, den, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* if xT == xP and yT + yP == 0, return xQ - xT
|
||||
*/
|
||||
|
||||
if (BN_cmp(xT, xP) == 0) {
|
||||
BIGNUM *t;
|
||||
if (!(t = BN_CTX_get(bn_ctx))) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_add(t, yT, yP, p, ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (BN_is_zero(t)) {
|
||||
if (!BN_GFP2_sub_bn(r, xQ, xT, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* if T == P, slope = (3 * x_T^2 + a)/(2 * y_T)
|
||||
* else slope = (y_T - y_P)/(x_T - x_P)
|
||||
*/
|
||||
if (!BN_mod_sub(num, yT, yP, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_sub(den, xT, xP, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_inverse(den, den, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_mul(slope, num, den, p, bn_ctx)) {
|
||||
goto end;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* num = (yQ - ((xQ - xT) * slope)) - yT
|
||||
* den = xQ + (xT + (xP - slope^2))
|
||||
* return num/den
|
||||
*/
|
||||
|
||||
if (!BN_GFP2_sub_bn(num, xQ, xT, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_GFP2_mul_bn(num, num, slope, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_GFP2_sub(num, yQ, num, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_GFP2_sub_bn(num, num, yT, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!BN_mod_sqr(bn, slope, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_sub(bn, xP, bn, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_mod_add(bn, xT, bn, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_GFP2_add_bn(den, xQ, bn, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
#if 0
|
||||
//warning
|
||||
if (!BN_GFP2_div(ret, num, den, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_LINE_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
#endif
|
||||
|
||||
ret = 1;
|
||||
|
||||
end:
|
||||
BN_CTX_end(bn_ctx);
|
||||
BN_GFP2_free(num);
|
||||
BN_GFP2_free(den);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int type1curve_eval_miller_textbook(const EC_GROUP *group, BN_GFP2 *r,
|
||||
const EC_POINT *P, const BN_GFP2 *xQ, const BN_GFP2 *yQ,
|
||||
const BIGNUM *p, BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BN_GFP2 *f = NULL;
|
||||
BN_GFP2 *g = NULL;
|
||||
EC_POINT *T = NULL;
|
||||
BIGNUM *n;
|
||||
int nbits;
|
||||
int i;
|
||||
|
||||
if (!group || !r || !P || !xQ || !yQ || !p || !bn_ctx) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
n = BN_CTX_get(bn_ctx);
|
||||
|
||||
f = BN_GFP2_new();
|
||||
g = BN_GFP2_new();
|
||||
T = EC_POINT_new(group);
|
||||
|
||||
if (!n || !f || !g || !T) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_GROUP_get_order(group, n, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
nbits = BN_num_bits(n);
|
||||
|
||||
/* miller loop */
|
||||
for (i = nbits - 2; i >= 0; i--) {
|
||||
|
||||
/* f = f^2 */
|
||||
if (!BN_GFP2_sqr(f, f, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* compute g_{T,T}(Q) */
|
||||
if (!type1curve_eval_line_textbook(group, g, T, T, xQ, yQ,
|
||||
bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* f = f * g */
|
||||
if (!BN_GFP2_mul(f, f, g, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* T = 2T */
|
||||
if (!EC_POINT_dbl(group, T, T, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (BN_is_bit_set(n, i)) {
|
||||
|
||||
/* g = g_{T,P}(Q) */
|
||||
if (!type1curve_eval_line_textbook(group, g, T, P, xQ,
|
||||
yQ, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* f = f * g */
|
||||
if (!BN_GFP2_mul(f, f, g, p, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* T = T + P */
|
||||
if (!EC_POINT_add(group, T, T, P, bn_ctx)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK,
|
||||
ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* set return value */
|
||||
if (!BN_GFP2_copy(r, f)) {
|
||||
ECerr(EC_F_TYPE1CURVE_EVAL_MILLER_TEXTBOOK, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
ret = 1;
|
||||
|
||||
end:
|
||||
BN_CTX_end(bn_ctx);
|
||||
BN_GFP2_free(f);
|
||||
BN_GFP2_free(g);
|
||||
EC_POINT_free(T);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int EC_type1curve_tate(const EC_GROUP *group, BN_GFP2 *r,
|
||||
const EC_POINT *P, const EC_POINT *Q, BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BN_GFP2 *xQ = NULL;
|
||||
BN_GFP2 *yQ = NULL;
|
||||
BIGNUM *eta = NULL;
|
||||
BIGNUM *p;
|
||||
BIGNUM *a;
|
||||
BIGNUM *b;
|
||||
|
||||
if (!group || !ret || !P || !Q || !bn_ctx) {
|
||||
ECerr(EC_F_EC_TYPE1CURVE_TATE, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
|
||||
xQ = BN_GFP2_new();
|
||||
yQ = BN_GFP2_new();
|
||||
p = BN_CTX_get(bn_ctx);
|
||||
a = BN_CTX_get(bn_ctx);
|
||||
b = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!xQ || !yQ || !p || !a || !b) {
|
||||
ECerr(EC_F_EC_TYPE1CURVE_TATE, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (!EC_GROUP_get_curve_GFp(group, p, a, b, bn_ctx)) {
|
||||
ECerr(EC_F_EC_TYPE1CURVE_TATE, EC_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* (xQ, yQ) = phi(Q) */
|
||||
if (!type1curve_phi(group, Q, xQ, yQ, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_TYPE1CURVE_TATE, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* compute e(P, phi(Q)) */
|
||||
if (!type1curve_eval_miller_textbook(group, r, P, xQ, yQ, p, bn_ctx)) {
|
||||
ECerr(EC_F_EC_TYPE1CURVE_TATE, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
/* compute e(P, phi(Q))^eta, eta = (p^2 - 1)/q */
|
||||
if (!(eta = EC_GROUP_get_type1curve_eta(group, bn_ctx))) {
|
||||
ECerr(EC_F_EC_TYPE1CURVE_TATE, EC_R_INVALID_TYPE1CURVE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
|
||||
end:
|
||||
BN_GFP2_free(xQ);
|
||||
BN_GFP2_free(yQ);
|
||||
BN_CTX_end(bn_ctx);
|
||||
BN_free(eta);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int EC_type1curve_tate_ratio(const EC_GROUP *group, BN_GFP2 *r,
|
||||
const EC_POINT *P1, const EC_POINT *Q1,
|
||||
const EC_POINT *P2, const EC_POINT *Q2,
|
||||
BN_CTX *bn_ctx)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if 0
|
||||
typedef struct {
|
||||
int security_bits;
|
||||
int n_bits;
|
||||
int p_bits;
|
||||
int q_bits;
|
||||
} TYPE1CURVE_SEC;
|
||||
|
||||
static TYPE1CURVE_SEC sec_tbl[] = {
|
||||
/* k |n| |p| |q| */
|
||||
{ 80, 1024, 512, 160},
|
||||
{112, 2048, 1024, 224},
|
||||
{128, 3072, 1536, 256},
|
||||
{192, 7680, 3840, 384},
|
||||
{256, 15360, 7680, 512}
|
||||
};
|
||||
#endif
|
||||
|
||||
const EVP_MD *TYPE1CURVE_nbits_to_md(int nbits)
|
||||
{
|
||||
switch (nbits) {
|
||||
case 1024: return EVP_sha1();
|
||||
case 2048: return EVP_sha224();
|
||||
case 3072: return EVP_sha256();
|
||||
case 7680: return EVP_sha384();
|
||||
case 15360: return EVP_sha512();
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -1,114 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2016 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
/*
|
||||
* this file is to implement elliptic curve operations over extension
|
||||
* fields
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <openssl/bn.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/asn1.h>
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/fppoint.h>
|
||||
|
||||
ASN1_SEQUENCE(FpPoint) = {
|
||||
ASN1_SIMPLE(FpPoint, x, BIGNUM),
|
||||
ASN1_SIMPLE(FpPoint, y, BIGNUM)
|
||||
} ASN1_SEQUENCE_END(FpPoint)
|
||||
IMPLEMENT_ASN1_FUNCTIONS(FpPoint)
|
||||
IMPLEMENT_ASN1_DUP_FUNCTION(FpPoint)
|
||||
|
||||
int EC_POINT_cmp_fppoint(const EC_GROUP *group, const EC_POINT *a, const FpPoint *b,
|
||||
BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = -1;
|
||||
BIGNUM *x = NULL;
|
||||
BIGNUM *y = NULL;
|
||||
|
||||
if (!group || !a || !b || !bn_ctx) {
|
||||
ECerr(EC_F_EC_POINT_CMP_FPPOINT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return -1;
|
||||
}
|
||||
|
||||
BN_CTX_start(bn_ctx);
|
||||
x = BN_CTX_get(bn_ctx);
|
||||
y = BN_CTX_get(bn_ctx);
|
||||
|
||||
if (!x || !y) {
|
||||
ECerr(EC_F_EC_POINT_CMP_FPPOINT, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) == NID_X9_62_prime_field) {
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(group, a, x, y, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_CMP_FPPOINT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
} else {
|
||||
if (!EC_POINT_get_affine_coordinates_GF2m(group, a, x, y, bn_ctx)) {
|
||||
ECerr(EC_F_EC_POINT_CMP_FPPOINT, ERR_R_EC_LIB);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
if (BN_cmp(x, b->x) == 0 && BN_cmp(y, b->y) == 0) {
|
||||
ret = 0;
|
||||
} else {
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
end:
|
||||
BN_CTX_end(bn_ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
|
||||
|
||||
|
||||
typedef struct pairing_parameters_st {
|
||||
long version;
|
||||
ASN1_OBJECT *cid;
|
||||
ASN1_INTEGER *p;
|
||||
ASN1_INTEGER *a;
|
||||
ASN1_INTEGER *b;
|
||||
ASN1_OBJECT *beta;
|
||||
ASN1_INTEGER *cofactor;
|
||||
ASN1_INTEGER *order;
|
||||
ASN1_INTEGER *embedded_degree;
|
||||
ASN1_OCTET_STRING *G1;
|
||||
ASN1_OCTET_STRING *G2;
|
||||
ASN1_TYPE *eid;
|
||||
ASN1_INTEGER *d1;
|
||||
ASN1_INTEGER *d2;
|
||||
ANS1_OBJECT *phi;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -60,12 +60,9 @@ static ERR_STRING_DATA ERR_str_libraries[] = {
|
||||
{ERR_PACK(ERR_LIB_ASYNC, 0, 0), "ASYNC routines"},
|
||||
{ERR_PACK(ERR_LIB_KDF, 0, 0), "KDF routines"},
|
||||
{ERR_PACK(ERR_LIB_KDF2, 0, 0), "KDF2 routines"},
|
||||
{ERR_PACK(ERR_LIB_FFX, 0, 0), "FFX routines"},
|
||||
{ERR_PACK(ERR_LIB_PAILLIER, 0, 0), "PAILLIER routines"},
|
||||
{ERR_PACK(ERR_LIB_OTP, 0, 0), "OTP routines"},
|
||||
{ERR_PACK(ERR_LIB_GMAPI, 0, 0), "GMAPI routines"},
|
||||
{ERR_PACK(ERR_LIB_BFIBE, 0, 0), "BFIBE routines"},
|
||||
{ERR_PACK(ERR_LIB_BB1IBE, 0, 0), "BB1IBE routines"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, 0), "SM2 routines"},
|
||||
{ERR_PACK(ERR_LIB_SM9, 0, 0), "SM9 routines"},
|
||||
{ERR_PACK(ERR_LIB_SDF, 0, 0), "SDF routines"},
|
||||
@@ -116,12 +113,9 @@ static ERR_STRING_DATA ERR_str_reasons[] = {
|
||||
{ERR_R_ENGINE_LIB, "ENGINE lib"},
|
||||
{ERR_R_ECDSA_LIB, "ECDSA lib"},
|
||||
{ERR_R_KDF2_LIB, "KDF2 lib"},
|
||||
{ERR_R_FFX_LIB, "FFX lib"},
|
||||
{ERR_R_PAILLIER_LIB, "PAILLIER lib"},
|
||||
{ERR_R_OTP_LIB, "OTP lib"},
|
||||
{ERR_R_GMAPI_LIB, "GMAPI lib"},
|
||||
{ERR_R_BFIBE_LIB, "BFIBE lib"},
|
||||
{ERR_R_BB1IBE_LIB, "BB1IBE lib"},
|
||||
{ERR_R_SM2_LIB, "SM2 lib"},
|
||||
{ERR_R_SM9_LIB, "SM9 lib"},
|
||||
{ERR_R_SDF_LIB, "SDF lib"},
|
||||
|
||||
@@ -66,9 +66,6 @@
|
||||
#endif
|
||||
#include <openssl/kdf.h>
|
||||
#include <openssl/kdf2.h>
|
||||
#ifndef OPENSSL_NO_FFX
|
||||
# include <openssl/ffx.h>
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_PAILLIER
|
||||
# include <openssl/paillier.h>
|
||||
#endif
|
||||
@@ -78,12 +75,6 @@
|
||||
#ifndef OPENSSL_NO_GMAPI
|
||||
# include <openssl/gmapi.h>
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_BFIBE
|
||||
# include <openssl/bfibe.h>
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_BB1IBE
|
||||
# include <openssl/bb1ibe.h>
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_SM2
|
||||
# include <openssl/sm2.h>
|
||||
#endif
|
||||
@@ -167,9 +158,6 @@ int err_load_crypto_strings_int(void)
|
||||
# ifndef OPENSSL_NO_KDF2
|
||||
ERR_load_KDF2_strings() == 0 ||
|
||||
# endif
|
||||
# ifndef OPENSSL_NO_FFX
|
||||
ERR_load_FFX_strings() == 0 ||
|
||||
# endif
|
||||
# ifndef OPENSSL_NO_PAILLIER
|
||||
ERR_load_PAILLIER_strings() == 0 ||
|
||||
# endif
|
||||
@@ -179,12 +167,6 @@ int err_load_crypto_strings_int(void)
|
||||
# ifndef OPENSSL_NO_GMAPI
|
||||
ERR_load_GMAPI_strings() == 0 ||
|
||||
# endif
|
||||
# ifndef OPENSSL_NO_BFIBE
|
||||
ERR_load_BFIBE_strings() == 0 ||
|
||||
# endif
|
||||
# ifndef OPENSSL_NO_BB1IBE
|
||||
ERR_load_BB1IBE_strings() == 0 ||
|
||||
# endif
|
||||
# ifndef OPENSSL_NO_SM2
|
||||
ERR_load_SM2_strings() == 0 ||
|
||||
# endif
|
||||
|
||||
@@ -36,12 +36,9 @@ L CT include/openssl/ct.h crypto/ct/ct_err.c
|
||||
L ASYNC include/openssl/async.h crypto/async/async_err.c
|
||||
L KDF include/openssl/kdf.h crypto/kdf/kdf_err.c
|
||||
L KDF2 include/openssl/kdf2.h crypto/kdf2/kdf2_err.c
|
||||
L FFX include/openssl/ffx.h crypto/ffx/ffx_err.c
|
||||
L PAILLIER include/openssl/paillier.h crypto/paillier/pai_err.c
|
||||
L OTP include/openssl/otp.h crypto/otp/otp_err.c
|
||||
L GMAPI include/openssl/gmapi.h crypto/gmapi/gmapi_err.c
|
||||
L BFIBE include/openssl/bfibe.h crypto/bfibe/bfibe_err.c
|
||||
L BB1IBE include/openssl/bb1ibe.h crypto/bb1ibe/bb1ibe_err.c
|
||||
L SM2 include/openssl/sm2.h crypto/sm2/sm2_err.c
|
||||
L SM9 include/openssl/sm9.h crypto/sm9/sm9_err.c
|
||||
L SDF include/openssl/gmsdf.h crypto/sdf/sdf_err.c
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=ffx.c ffx_err.c
|
||||
351
crypto/ffx/ffx.c
351
crypto/ffx/ffx.c
@@ -1,351 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/ffx.h>
|
||||
#include <openssl/e_os2.h>
|
||||
#include "../modes/modes_lcl.h"
|
||||
|
||||
|
||||
static uint32_t modulo[] = {
|
||||
1,
|
||||
10,
|
||||
100,
|
||||
1000,
|
||||
10000,
|
||||
100000,
|
||||
1000000,
|
||||
10000000,
|
||||
100000000,
|
||||
1000000000,
|
||||
1000000000,
|
||||
};
|
||||
|
||||
struct FFX_CTX_st {
|
||||
EVP_CIPHER_CTX *cctx;
|
||||
int flag;
|
||||
};
|
||||
|
||||
FFX_CTX *FFX_CTX_new(void)
|
||||
{
|
||||
FFX_CTX *ret = NULL;
|
||||
ret = OPENSSL_zalloc(sizeof(*ret));
|
||||
return ret;
|
||||
}
|
||||
|
||||
void FFX_CTX_free(FFX_CTX *ctx)
|
||||
{
|
||||
if (ctx) {
|
||||
EVP_CIPHER_CTX_free(ctx->cctx);
|
||||
}
|
||||
OPENSSL_free(ctx);
|
||||
}
|
||||
|
||||
int FFX_init(FFX_CTX *ctx, const EVP_CIPHER *cipher, const unsigned char *key,
|
||||
int flag)
|
||||
{
|
||||
int ret = 0;
|
||||
EVP_CIPHER_CTX *cctx = NULL;
|
||||
|
||||
if (!ctx || !cipher || !key) {
|
||||
FFXerr(FFX_F_FFX_INIT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
if (EVP_CIPHER_mode(cipher) != EVP_CIPH_ECB_MODE) {
|
||||
FFXerr(FFX_F_FFX_INIT, FFX_R_INVALID_CIPHER_MODE);
|
||||
return 0;
|
||||
}
|
||||
if (EVP_CIPHER_block_size(cipher) != 16) {
|
||||
FFXerr(FFX_F_FFX_INIT, FFX_R_INVALID_BLOCK_SIZE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!ctx->cctx) {
|
||||
if (!(cctx = EVP_CIPHER_CTX_new())) {
|
||||
FFXerr(FFX_F_FFX_INIT, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
ctx->cctx = cctx;
|
||||
cctx = NULL;
|
||||
}
|
||||
ctx->flag = flag;
|
||||
|
||||
if (!EVP_EncryptInit_ex(ctx->cctx, cipher, NULL, key, NULL)) {
|
||||
FFXerr(FFX_F_FFX_INIT, FFX_R_ENCRYPT_INIT_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
end:
|
||||
EVP_CIPHER_CTX_free(cctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int FFX_encrypt(FFX_CTX *ctx, const char *in, char *out, size_t iolen,
|
||||
unsigned char *tweak, size_t tweaklen)
|
||||
{
|
||||
int llen, rlen;
|
||||
uint32_t lval, rval;
|
||||
unsigned char pblock[16] = {
|
||||
0x01, 0x02, 0x01, 0x0a, 0x00, 0x00, 0x0a, 0xff,
|
||||
0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00};
|
||||
unsigned char qblock[16];
|
||||
char lbuf[FFX_MAX_DIGITS/2 + 2];
|
||||
uint64_t yval;
|
||||
size_t i;
|
||||
|
||||
if (!ctx || !in || !out || !tweak) {
|
||||
FFXerr(FFX_F_FFX_ENCRYPT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (iolen < FFX_MIN_DIGITS || iolen > FFX_MAX_DIGITS) {
|
||||
FFXerr(FFX_F_FFX_ENCRYPT, FFX_R_INVALID_INPUT_LENGTH);
|
||||
return 0;
|
||||
}
|
||||
|
||||
for (i = 0; i < iolen; i++) {
|
||||
if (!isdigit(in[i])) {
|
||||
FFXerr(FFX_F_FFX_ENCRYPT, FFX_R_INVALID_INPUT_DIGIT);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
llen = iolen / 2;
|
||||
rlen = iolen - llen;
|
||||
|
||||
if (tweaklen < FFX_MIN_TWEAKLEN || tweaklen > FFX_MAX_TWEAKLEN) {
|
||||
FFXerr(FFX_F_FFX_ENCRYPT, FFX_R_INVALID_TWEAK_LENGTH);
|
||||
return 0;
|
||||
}
|
||||
|
||||
memcpy(lbuf, in, llen);
|
||||
lbuf[llen] = 0;
|
||||
lval = atoi(lbuf);
|
||||
rval = atoi(in + llen);
|
||||
|
||||
pblock[7] = llen & 0xff;
|
||||
pblock[8] = iolen & 0xff;
|
||||
pblock[12] = tweaklen & 0xff;
|
||||
|
||||
if (!EVP_Cipher(ctx->cctx, pblock, pblock,
|
||||
EVP_CIPHER_CTX_block_size(ctx->cctx))) {
|
||||
FFXerr(FFX_F_FFX_ENCRYPT, ERR_R_EVP_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
memset(qblock, 0, sizeof(qblock));
|
||||
memcpy(qblock, tweak, tweaklen);
|
||||
|
||||
for (i = 0; i < FFX_NUM_ROUNDS; i += 2) {
|
||||
|
||||
unsigned char rblock[16];
|
||||
size_t j;
|
||||
|
||||
qblock[11] = i & 0xff;
|
||||
memcpy(qblock + 12, &rval, sizeof(rval));
|
||||
for (j = 0; j < sizeof(rblock); j++) {
|
||||
rblock[j] = pblock[j] ^ qblock[j];
|
||||
}
|
||||
if (!EVP_Cipher(ctx->cctx, rblock, rblock,
|
||||
EVP_CIPHER_CTX_block_size(ctx->cctx))) {
|
||||
FFXerr(FFX_F_FFX_ENCRYPT, ERR_R_EVP_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
yval = *((uint64_t *)rblock) % modulo[llen];
|
||||
lval = (lval + yval) % modulo[llen];
|
||||
|
||||
qblock[11] = (i + 1) & 0xff;
|
||||
memcpy(qblock + 12, &lval, sizeof(lval));
|
||||
for (j = 0; j < sizeof(rblock); j++) {
|
||||
rblock[j] = pblock[j] ^ qblock[j];
|
||||
}
|
||||
if (!EVP_Cipher(ctx->cctx, rblock, rblock,
|
||||
EVP_CIPHER_CTX_block_size(ctx->cctx))) {
|
||||
FFXerr(FFX_F_FFX_ENCRYPT, ERR_R_EVP_LIB);
|
||||
return 0;
|
||||
}
|
||||
yval = *((uint64_t *)rblock) % modulo[rlen];
|
||||
rval = (rval + yval) % modulo[rlen];
|
||||
}
|
||||
|
||||
memset(out, '0', iolen);
|
||||
sprintf(lbuf, "%d", rval);
|
||||
memcpy(out + rlen - strlen(lbuf), lbuf, strlen(lbuf));
|
||||
sprintf(lbuf, "%d", lval);
|
||||
strcpy(out + iolen - strlen(lbuf), lbuf);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int FFX_decrypt(FFX_CTX *ctx, const char *in, char *out, size_t iolen,
|
||||
unsigned char *tweak, size_t tweaklen)
|
||||
{
|
||||
int llen, rlen;
|
||||
uint32_t lval, rval;
|
||||
unsigned char pblock[16] = {
|
||||
0x01, 0x02, 0x01, 0x0a, 0x00, 0x00, 0x0a, 0xff,
|
||||
0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00};
|
||||
unsigned char qblock[16];
|
||||
char lbuf[FFX_MAX_DIGITS/2 + 2];
|
||||
uint64_t yval;
|
||||
size_t i;
|
||||
|
||||
if (!ctx || !in || !out || !tweak) {
|
||||
FFXerr(FFX_F_FFX_DECRYPT, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (iolen < FFX_MIN_DIGITS || iolen > FFX_MAX_DIGITS) {
|
||||
FFXerr(FFX_F_FFX_DECRYPT, FFX_R_INVALID_INPUT_LENGTH);
|
||||
return 0;
|
||||
}
|
||||
|
||||
for (i = 0; i < iolen; i++) {
|
||||
if (!isdigit(in[i])) {
|
||||
FFXerr(FFX_F_FFX_DECRYPT, FFX_R_INVALID_INPUT_DIGIT);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
rlen = iolen / 2;
|
||||
llen = iolen - rlen;
|
||||
|
||||
|
||||
if (tweaklen < FFX_MIN_TWEAKLEN || tweaklen > FFX_MAX_TWEAKLEN) {
|
||||
FFXerr(FFX_F_FFX_DECRYPT, FFX_R_INVALID_TWEAK_LENGTH);
|
||||
return 0;
|
||||
}
|
||||
|
||||
memcpy(lbuf, in, llen);
|
||||
lbuf[llen] = 0;
|
||||
lval = atoi(lbuf);
|
||||
rval = atoi(in + llen);
|
||||
|
||||
pblock[7] = rlen & 0xff;
|
||||
pblock[8] = iolen & 0xff;
|
||||
pblock[12] = tweaklen & 0xff;
|
||||
|
||||
if (!EVP_Cipher(ctx->cctx, pblock, pblock,
|
||||
EVP_CIPHER_CTX_block_size(ctx->cctx))) {
|
||||
FFXerr(FFX_F_FFX_DECRYPT, ERR_R_EVP_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
memset(qblock, 0, sizeof(qblock));
|
||||
memcpy(qblock, tweak, tweaklen);
|
||||
|
||||
for (i = FFX_NUM_ROUNDS - 1; i > 0; i -= 2) {
|
||||
|
||||
unsigned char rblock[16];
|
||||
size_t j;
|
||||
|
||||
qblock[11] = i & 0xff;
|
||||
memcpy(qblock + 12, &rval, sizeof(rval));
|
||||
for (j = 0; j < sizeof(rblock); j++) {
|
||||
rblock[j] = pblock[j] ^ qblock[j];
|
||||
}
|
||||
if (!EVP_Cipher(ctx->cctx, rblock, rblock,
|
||||
EVP_CIPHER_CTX_block_size(ctx->cctx))) {
|
||||
FFXerr(FFX_F_FFX_DECRYPT, ERR_R_EVP_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
yval = *((uint64_t *)rblock) % modulo[llen];
|
||||
lval = (lval >= yval) ? (lval - yval) : lval + modulo[llen] - yval;
|
||||
|
||||
qblock[11] = (i - 1) & 0xff;
|
||||
memcpy(qblock + 12, &lval, sizeof(lval));
|
||||
for (j = 0; j < sizeof(rblock); j++) {
|
||||
rblock[j] = pblock[j] ^ qblock[j];
|
||||
}
|
||||
if (!EVP_Cipher(ctx->cctx, rblock, rblock,
|
||||
EVP_CIPHER_CTX_block_size(ctx->cctx))) {
|
||||
FFXerr(FFX_F_FFX_DECRYPT, ERR_R_EVP_LIB);
|
||||
return 0;
|
||||
}
|
||||
|
||||
yval = *((uint64_t *)rblock) % modulo[rlen];
|
||||
rval = (rval >= yval) ? (rval - yval) : rval + modulo[rlen] - yval;
|
||||
}
|
||||
|
||||
memset(out, '0', iolen);
|
||||
sprintf(lbuf, "%d", rval);
|
||||
memcpy(out + rlen - strlen(lbuf), lbuf, strlen(lbuf));
|
||||
sprintf(lbuf, "%d", lval);
|
||||
strcpy(out + iolen - strlen(lbuf), lbuf);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int luhn_table[10] = {0, 2, 4, 6, 8, 1, 3, 5, 7, 9};
|
||||
|
||||
int FFX_compute_luhn(const char *in, size_t inlen)
|
||||
{
|
||||
int r = 0;
|
||||
int i;
|
||||
|
||||
for (i = inlen - 1; i >= 0; i--) {
|
||||
int a;
|
||||
if (!isdigit(in[i])) {
|
||||
return -2;
|
||||
}
|
||||
a = in[i] - '0';
|
||||
if (i % 2 != inlen % 2)
|
||||
a = luhn_table[a];
|
||||
r += a;
|
||||
}
|
||||
|
||||
r = ((r * 9) % 10) + '0';
|
||||
return r;
|
||||
}
|
||||
|
||||
@@ -1,50 +0,0 @@
|
||||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT
|
||||
* Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
* this file except in compliance with the License. You can obtain a copy
|
||||
* in the file LICENSE in the source distribution or at
|
||||
* https://www.openssl.org/source/license.html
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/ffx.h>
|
||||
|
||||
/* BEGIN ERROR CODES */
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
# define ERR_FUNC(func) ERR_PACK(ERR_LIB_FFX,func,0)
|
||||
# define ERR_REASON(reason) ERR_PACK(ERR_LIB_FFX,0,reason)
|
||||
|
||||
static ERR_STRING_DATA FFX_str_functs[] = {
|
||||
{ERR_FUNC(FFX_F_FFX_DECRYPT), "FFX_decrypt"},
|
||||
{ERR_FUNC(FFX_F_FFX_ENCRYPT), "FFX_encrypt"},
|
||||
{ERR_FUNC(FFX_F_FFX_INIT), "FFX_init"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
static ERR_STRING_DATA FFX_str_reasons[] = {
|
||||
{ERR_REASON(FFX_R_ENCRYPT_INIT_FAILURE), "encrypt init failure"},
|
||||
{ERR_REASON(FFX_R_INVALID_BLOCK_SIZE), "invalid block size"},
|
||||
{ERR_REASON(FFX_R_INVALID_CIPHER_MODE), "invalid cipher mode"},
|
||||
{ERR_REASON(FFX_R_INVALID_INPUT_DIGIT), "invalid input digit"},
|
||||
{ERR_REASON(FFX_R_INVALID_INPUT_LENGTH), "invalid input length"},
|
||||
{ERR_REASON(FFX_R_INVALID_TWEAK_LENGTH), "invalid tweak length"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
int ERR_load_FFX_strings(void)
|
||||
{
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
if (ERR_func_error_string(FFX_str_functs[0].error) == NULL) {
|
||||
ERR_load_strings(0, FFX_str_functs);
|
||||
ERR_load_strings(0, FFX_str_reasons);
|
||||
}
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
@@ -383,9 +383,6 @@ struct evp_pkey_st {
|
||||
# ifndef OPENSSL_NO_SM9 /* SM9 */
|
||||
struct SM9_MASTER_KEY_st *sm9_master;
|
||||
struct SM9_KEY_st *sm9;
|
||||
# endif
|
||||
# ifndef OPENSSL_NO_CPK /* CPK */
|
||||
struct CPK_MASTER_SECERT *cpk;
|
||||
# endif
|
||||
} pkey;
|
||||
int save_parameters;
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=serpent.c
|
||||
@@ -1,308 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
/**
|
||||
Copyright © 2015 Odzhan
|
||||
Copyright © 2008 Daniel Otte
|
||||
All Rights Reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
3. The name of the author may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
THIS SOFTWARE IS PROVIDED BY AUTHORS "AS IS" AND ANY EXPRESS OR
|
||||
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
||||
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE. */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/serpent.h>
|
||||
#include "serpent_locl.h"
|
||||
|
||||
static void serpent_whiten(serpent_blk *dst, serpent_key_t *src, int idx) {
|
||||
uint8_t i;
|
||||
serpent_blk *p = (serpent_blk*)&src->x[idx];
|
||||
|
||||
for (i = 0; i<SERPENT_BLOCK_SIZE / 4; i++) {
|
||||
dst->w[i] ^= p->w[i];
|
||||
}
|
||||
}
|
||||
|
||||
static void permute(serpent_blk *out, serpent_blk *in, int type)
|
||||
{
|
||||
uint8_t cy;
|
||||
uint8_t n, m;
|
||||
|
||||
for (n = 0; n<SERPENT_BLOCK_SIZE / 4; n++) {
|
||||
out->w[n] = 0;
|
||||
}
|
||||
|
||||
if (type == SERPENT_IP)
|
||||
{
|
||||
for (n = 0; n<16; n++) {
|
||||
for (m = 0; m<8; m++) {
|
||||
cy = in->w[m % 4] & 1;
|
||||
in->w[m % 4] >>= 1;
|
||||
out->b[n] = (cy << 7) | (out->b[n] >> 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (n = 0; n<4; n++) {
|
||||
for (m = 0; m<32; m++) {
|
||||
cy = in->w[n] & 1;
|
||||
in->w[n] >>= 1;
|
||||
out->w[m % 4] = (cy << 31) | (out->w[m % 4] >> 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define HI_NIBBLE(b) (((b) >> 4) & 0x0F)
|
||||
#define LO_NIBBLE(b) ((b) & 0x0F)
|
||||
|
||||
static uint32_t serpent_gen_w(uint32_t *b, uint32_t i) {
|
||||
uint32_t ret;
|
||||
ret = b[0] ^ b[3] ^ b[5] ^ b[7] ^ GOLDEN_RATIO ^ i;
|
||||
return ROTL32(ret, 11);
|
||||
}
|
||||
|
||||
static void serpent_subbytes(serpent_blk *blk, uint32_t box_idx, int type)
|
||||
{
|
||||
serpent_blk tmp_blk, sb;
|
||||
uint8_t *sbp;
|
||||
uint8_t i, t;
|
||||
|
||||
uint8_t sbox[8][8] =
|
||||
{ { 0x83, 0x1F, 0x6A, 0xB5, 0xDE, 0x24, 0x07, 0xC9 },
|
||||
{ 0xCF, 0x72, 0x09, 0xA5, 0xB1, 0x8E, 0xD6, 0x43 },
|
||||
{ 0x68, 0x97, 0xC3, 0xFA, 0x1D, 0x4E, 0xB0, 0x25 },
|
||||
{ 0xF0, 0x8B, 0x9C, 0x36, 0x1D, 0x42, 0x7A, 0xE5 },
|
||||
{ 0xF1, 0x38, 0x0C, 0x6B, 0x52, 0xA4, 0xE9, 0xD7 },
|
||||
{ 0x5F, 0xB2, 0xA4, 0xC9, 0x30, 0x8E, 0x6D, 0x17 },
|
||||
{ 0x27, 0x5C, 0x48, 0xB6, 0x9E, 0xF1, 0x3D, 0x0A },
|
||||
{ 0xD1, 0x0F, 0x8E, 0xB2, 0x47, 0xAC, 0x39, 0x65 }
|
||||
};
|
||||
|
||||
uint8_t sbox_inv[8][8] =
|
||||
{ { 0x3D, 0x0B, 0x6A, 0xC5, 0xE1, 0x74, 0x9F, 0x28 },
|
||||
{ 0x85, 0xE2, 0x6F, 0x3C, 0x4B, 0x97, 0xD1, 0x0A },
|
||||
{ 0x9C, 0x4F, 0xEB, 0x21, 0x30, 0xD6, 0x85, 0x7A },
|
||||
{ 0x90, 0x7A, 0xEB, 0xD6, 0x53, 0x2C, 0x84, 0x1F },
|
||||
{ 0x05, 0x38, 0x9A, 0xE7, 0xC2, 0x6B, 0xF4, 0x1D },
|
||||
{ 0xF8, 0x92, 0x14, 0xED, 0x6B, 0x35, 0xC7, 0x0A },
|
||||
{ 0xAF, 0xD1, 0x35, 0x06, 0x94, 0x7E, 0xC2, 0xB8 },
|
||||
{ 0x03, 0xD6, 0xE9, 0x8F, 0xC5, 0x7B, 0x1A, 0x24 }
|
||||
};
|
||||
|
||||
box_idx &= 7;
|
||||
|
||||
if (type == SERPENT_ENCRYPT) {
|
||||
sbp = (uint8_t*)&sbox[box_idx][0];
|
||||
}
|
||||
else {
|
||||
sbp = (uint8_t*)&sbox_inv[box_idx][0];
|
||||
}
|
||||
|
||||
for (i = 0; i<16; i += 2) {
|
||||
t = sbp[i / 2];
|
||||
sb.b[i + 0] = LO_NIBBLE(t);
|
||||
sb.b[i + 1] = HI_NIBBLE(t);
|
||||
}
|
||||
|
||||
permute(&tmp_blk, blk, SERPENT_IP);
|
||||
|
||||
for (i = 0; i<SERPENT_BLOCK_SIZE; i++) {
|
||||
t = tmp_blk.b[i];
|
||||
tmp_blk.b[i] = (sb.b[HI_NIBBLE(t)] << 4) | sb.b[LO_NIBBLE(t)];
|
||||
}
|
||||
permute(blk, &tmp_blk, SERPENT_FP);
|
||||
}
|
||||
|
||||
static void serpent_lt(serpent_blk* x, int enc)
|
||||
{
|
||||
uint32_t x0, x1, x2, x3;
|
||||
|
||||
/* load */
|
||||
x0 = x->w[0];
|
||||
x1 = x->w[1];
|
||||
x2 = x->w[2];
|
||||
x3 = x->w[3];
|
||||
|
||||
if (enc == SERPENT_DECRYPT) {
|
||||
x2 = ROTL32(x2, 10);
|
||||
x0 = ROTR32(x0, 5);
|
||||
x2 ^= x3 ^ (x1 << 7);
|
||||
x0 ^= x1 ^ x3;
|
||||
x3 = ROTR32(x3, 7);
|
||||
x1 = ROTR32(x1, 1);
|
||||
x3 ^= x2 ^ (x0 << 3);
|
||||
x1 ^= x0 ^ x2;
|
||||
x2 = ROTR32(x2, 3);
|
||||
x0 = ROTR32(x0, 13);
|
||||
}
|
||||
else {
|
||||
x0 = ROTL32(x0, 13);
|
||||
x2 = ROTL32(x2, 3);
|
||||
x1 ^= x0 ^ x2;
|
||||
x3 ^= x2 ^ (x0 << 3);
|
||||
x1 = ROTL32(x1, 1);
|
||||
x3 = ROTL32(x3, 7);
|
||||
x0 ^= x1 ^ x3;
|
||||
x2 ^= x3 ^ (x1 << 7);
|
||||
x0 = ROTL32(x0, 5);
|
||||
x2 = ROTR32(x2, 10);
|
||||
}
|
||||
x->w[0] = x0;
|
||||
x->w[1] = x1;
|
||||
x->w[2] = x2;
|
||||
x->w[3] = x3;
|
||||
}
|
||||
|
||||
void serpent_set_encrypt_key(serpent_key_t *key, const unsigned char *user_key)
|
||||
{
|
||||
union {
|
||||
uint8_t b[32];
|
||||
uint32_t w[8];
|
||||
} s_ws;
|
||||
|
||||
uint32_t i, j;
|
||||
|
||||
/* copy key input to local buffer */
|
||||
memcpy(&s_ws.b[0], user_key, SERPENT_KEY256);
|
||||
|
||||
/* expand the key */
|
||||
for (i = 0; i <= SERPENT_ROUNDS; i++) {
|
||||
for (j = 0; j<4; j++) {
|
||||
key->x[i][j] = serpent_gen_w(s_ws.w, i * 4 + j);
|
||||
memmove(&s_ws.b, &s_ws.b[4], 7 * 4);
|
||||
s_ws.w[7] = key->x[i][j];
|
||||
}
|
||||
serpent_subbytes((serpent_blk*)&key->x[i], 3 - i, SERPENT_ENCRYPT);
|
||||
}
|
||||
}
|
||||
|
||||
void serpent_set_decrypt_key(serpent_key_t *key, const unsigned char *user_key)
|
||||
{
|
||||
union {
|
||||
uint8_t b[32];
|
||||
uint32_t w[8];
|
||||
} s_ws;
|
||||
|
||||
uint32_t i, j;
|
||||
|
||||
/* copy key input to local buffer */
|
||||
memcpy(&s_ws.b[0], user_key, SERPENT_KEY256);
|
||||
|
||||
/* expand the key */
|
||||
for (i = 0; i <= SERPENT_ROUNDS; i++) {
|
||||
for (j = 0; j<4; j++) {
|
||||
key->x[i][j] = serpent_gen_w(s_ws.w, i * 4 + j);
|
||||
memmove(&s_ws.b, &s_ws.b[4], 7 * 4);
|
||||
s_ws.w[7] = key->x[i][j];
|
||||
}
|
||||
serpent_subbytes((serpent_blk*)&key->x[i], 3 - i, SERPENT_ENCRYPT);
|
||||
}
|
||||
}
|
||||
|
||||
void serpent_encrypt(const void *in, void *out, serpent_key_t *key)
|
||||
{
|
||||
int8_t i;
|
||||
serpent_blk *_out = out;
|
||||
memcpy(out, in, SERPENT_BLOCK_SIZE);
|
||||
|
||||
i = 0;
|
||||
for (;;) {
|
||||
/* xor with subkey */
|
||||
serpent_whiten(_out, key, i);
|
||||
/* apply sbox */
|
||||
serpent_subbytes(_out, i, SERPENT_ENCRYPT);
|
||||
if (++i == SERPENT_ROUNDS)
|
||||
break;
|
||||
/* linear transformation */
|
||||
serpent_lt(_out, SERPENT_ENCRYPT);
|
||||
}
|
||||
serpent_whiten(_out, key, i);
|
||||
}
|
||||
|
||||
void serpent_decrypt(const void *in, void *out, serpent_key_t *key)
|
||||
{
|
||||
int8_t i;
|
||||
serpent_blk *_out = out;
|
||||
memcpy(out, in, SERPENT_BLOCK_SIZE);
|
||||
|
||||
|
||||
i = SERPENT_ROUNDS;
|
||||
serpent_whiten(_out, key, i);
|
||||
for (;;) {
|
||||
--i;
|
||||
/* apply sbox */
|
||||
serpent_subbytes(_out, i, SERPENT_DECRYPT);
|
||||
/* xor with subkey */
|
||||
serpent_whiten(_out, key, i);
|
||||
if (i == 0)
|
||||
break;
|
||||
/* linear transformation */
|
||||
serpent_lt(_out, SERPENT_DECRYPT);
|
||||
}
|
||||
}
|
||||
@@ -1,112 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
/**
|
||||
Copyright © 2015 Odzhan
|
||||
Copyright © 2008 Daniel Otte
|
||||
All Rights Reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions are
|
||||
met:
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
3. The name of the author may not be used to endorse or promote products
|
||||
derived from this software without specific prior written permission.
|
||||
THIS SOFTWARE IS PROVIDED BY AUTHORS "AS IS" AND ANY EXPRESS OR
|
||||
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
||||
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
||||
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE. */
|
||||
|
||||
#include <openssl/opensslconf.h>
|
||||
#include <openssl/e_os2.h>
|
||||
#include <openssl/serpent.h>
|
||||
|
||||
#ifdef INTRINSICS
|
||||
#define memcpy(x,y,z) __movsb(x,y,z)
|
||||
#define memmove(x,y,z) __movsb(x,y,z)
|
||||
#define memset(x,y,z) __stosb(x,y,z)
|
||||
#define ROTL32(x,r) _rotl(x,r)
|
||||
#define ROTR32(x,r) _rotr(x,r)
|
||||
#else
|
||||
|
||||
#define U8V(v) ((uint8_t)(v) & 0xFFU)
|
||||
#define U16V(v) ((uint16_t)(v) & 0xFFFFU)
|
||||
#define U32V(v) ((uint32_t)(v) & 0xFFFFFFFFUL)
|
||||
#define U64V(v) ((uint64_t)(v) & 0xFFFFFFFFFFFFFFFFULL)
|
||||
|
||||
#define ROTL8(v, n) \
|
||||
(U8V((v) << (n)) | ((v) >> (8 - (n))))
|
||||
|
||||
#define ROTL16(v, n) \
|
||||
(U16V((v) << (n)) | ((v) >> (16 - (n))))
|
||||
|
||||
#define ROTL32(v, n) \
|
||||
(U32V((v) << (n)) | ((v) >> (32 - (n))))
|
||||
|
||||
#define ROTL64(v, n) \
|
||||
(U64V((v) << (n)) | ((v) >> (64 - (n))))
|
||||
|
||||
#define ROTR8(v, n) ROTL8(v, 8 - (n))
|
||||
#define ROTR16(v, n) ROTL16(v, 16 - (n))
|
||||
#define ROTR32(v, n) ROTL32(v, 32 - (n))
|
||||
#define ROTR64(v, n) ROTL64(v, 64 - (n))
|
||||
|
||||
#endif
|
||||
|
||||
#define GOLDEN_RATIO 0x9e3779b9l
|
||||
@@ -1 +0,0 @@
|
||||
#! /usr/bin/env perl
|
||||
@@ -1 +1,289 @@
|
||||
#! /usr/bin/env perl
|
||||
|
||||
$flavour = shift;
|
||||
$output = shift;
|
||||
if ($flavour =~ /\./) { $output = $flavour; undef $flavour; }
|
||||
|
||||
$win64=0; $win64=1 if ($flavour =~ /[nm]asm|mingw64/ || $output =~ /\.asm$/);
|
||||
|
||||
$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
|
||||
( $xlate="${dir}x86_64-xlate.pl" and -f $xlate ) or
|
||||
( $xlate="${dir}../../perlasm/x86_64-xlate.pl" and -f $xlate) or
|
||||
die "can't locate x86_64-xlate.pl";
|
||||
|
||||
if (`$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
|
||||
=~ /GNU assembler version ([2-9]\.[0-9]+)/) {
|
||||
$avx = ($1>=2.19) + ($1>=2.22);
|
||||
}
|
||||
|
||||
if (!$avx && $win64 && ($flavour =~ /nasm/ || $ENV{ASM} =~ /nasm/) &&
|
||||
`nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/) {
|
||||
$avx = ($1>=2.09) + ($1>=2.10);
|
||||
}
|
||||
|
||||
if (!$avx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
|
||||
`ml64 2>&1` =~ /Version ([0-9]+)\./) {
|
||||
$avx = ($1>=10) + ($1>=11);
|
||||
}
|
||||
|
||||
if (!$avx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|.*based on LLVM) ([3-9]\.[0-9]+)/) {
|
||||
$avx = ($2>=3.0) + ($2>3.0);
|
||||
}
|
||||
|
||||
$avx=1 if ($avx);
|
||||
|
||||
open OUT,"| \"$^X\" \"$xlate\" $flavour \"$output\"";
|
||||
*STDOUT=*OUT;
|
||||
|
||||
$func="sm3_block_data_order";
|
||||
$TABLE="K256";
|
||||
$SZ=4;
|
||||
@ROT=($A,$B,$C,$D,$E,$F,$G,$H)=("%eax","%ebx","%ecx","%edx",
|
||||
"%r8d","%r9d","%r10d","%r11d");
|
||||
($T1,$a0,$a1,$a2,$a3)=("%r12d","%r13d","%r14d","%r15d","%edi");
|
||||
@Sigma0=( 2,13,22);
|
||||
@Sigma1=( 6,11,25);
|
||||
@sigma0=( 7,18, 3);
|
||||
@sigma1=(17,19,10);
|
||||
$rounds=64;
|
||||
|
||||
$ctx="%rdi"; # 1st arg, zapped by $a3
|
||||
$inp="%rsi"; # 2nd arg
|
||||
$Tbl="%rbp";
|
||||
|
||||
$_ctx="16*$SZ+0*8(%rsp)";
|
||||
$_inp="16*$SZ+1*8(%rsp)";
|
||||
$_end="16*$SZ+2*8(%rsp)";
|
||||
$_rsp="16*$SZ+3*8(%rsp)";
|
||||
$framesz="16*$SZ+4*8";
|
||||
|
||||
|
||||
sub ROUND_00_15()
|
||||
{ my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
|
||||
my $STRIDE=$SZ;
|
||||
$STRIDE += 16 if ($i%(16/$SZ)==(16/$SZ-1));
|
||||
|
||||
$code.=<<___;
|
||||
ror \$`$Sigma1[2]-$Sigma1[1]`,$a0
|
||||
mov $f,$a2
|
||||
|
||||
xor $e,$a0
|
||||
ror \$`$Sigma0[2]-$Sigma0[1]`,$a1
|
||||
xor $g,$a2 # f^g
|
||||
|
||||
mov $T1,`$SZ*($i&0xf)`(%rsp)
|
||||
xor $a,$a1
|
||||
and $e,$a2 # (f^g)&e
|
||||
|
||||
ror \$`$Sigma1[1]-$Sigma1[0]`,$a0
|
||||
add $h,$T1 # T1+=h
|
||||
xor $g,$a2 # Ch(e,f,g)=((f^g)&e)^g
|
||||
|
||||
ror \$`$Sigma0[1]-$Sigma0[0]`,$a1
|
||||
xor $e,$a0
|
||||
add $a2,$T1 # T1+=Ch(e,f,g)
|
||||
|
||||
mov $a,$a2
|
||||
add ($Tbl),$T1 # T1+=K[round]
|
||||
xor $a,$a1
|
||||
|
||||
xor $b,$a2 # a^b, b^c in next round
|
||||
ror \$$Sigma1[0],$a0 # Sigma1(e)
|
||||
mov $b,$h
|
||||
|
||||
and $a2,$a3
|
||||
ror \$$Sigma0[0],$a1 # Sigma0(a)
|
||||
add $a0,$T1 # T1+=Sigma1(e)
|
||||
|
||||
xor $a3,$h # h=Maj(a,b,c)=Ch(a^b,c,b)
|
||||
add $T1,$d # d+=T1
|
||||
add $T1,$h # h+=T1
|
||||
|
||||
lea $STRIDE($Tbl),$Tbl # round++
|
||||
___
|
||||
$code.=<<___ if ($i<15);
|
||||
add $a1,$h # h+=Sigma0(a)
|
||||
___
|
||||
($a2,$a3) = ($a3,$a2);
|
||||
}
|
||||
|
||||
sub ROUND_16_XX()
|
||||
{ my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
|
||||
|
||||
$code.=<<___;
|
||||
mov `$SZ*(($i+1)&0xf)`(%rsp),$a0
|
||||
mov `$SZ*(($i+14)&0xf)`(%rsp),$a2
|
||||
|
||||
mov $a0,$T1
|
||||
ror \$`$sigma0[1]-$sigma0[0]`,$a0
|
||||
add $a1,$a # modulo-scheduled h+=Sigma0(a)
|
||||
mov $a2,$a1
|
||||
ror \$`$sigma1[1]-$sigma1[0]`,$a2
|
||||
|
||||
xor $T1,$a0
|
||||
shr \$$sigma0[2],$T1
|
||||
ror \$$sigma0[0],$a0
|
||||
xor $a1,$a2
|
||||
shr \$$sigma1[2],$a1
|
||||
|
||||
ror \$$sigma1[0],$a2
|
||||
xor $a0,$T1 # sigma0(X[(i+1)&0xf])
|
||||
xor $a1,$a2 # sigma1(X[(i+14)&0xf])
|
||||
add `$SZ*(($i+9)&0xf)`(%rsp),$T1
|
||||
|
||||
add `$SZ*($i&0xf)`(%rsp),$T1
|
||||
mov $e,$a0
|
||||
add $a2,$T1
|
||||
mov $a,$a1
|
||||
___
|
||||
&ROUND_00_15(@_);
|
||||
}
|
||||
|
||||
$code=<<___;
|
||||
.text
|
||||
|
||||
.extern OPENSSL_ia32cap_P
|
||||
.globl $func
|
||||
.type $func,\@function,3
|
||||
.align 16
|
||||
$func:
|
||||
___
|
||||
$code.=<<___;
|
||||
push %rbx
|
||||
push %rbp
|
||||
push %r12
|
||||
push %r13
|
||||
push %r14
|
||||
push %r15
|
||||
mov %rsp,%r11 # copy %rsp
|
||||
shl \$4,%rdx # num*16
|
||||
sub \$$framesz,%rsp
|
||||
lea ($inp,%rdx,$SZ),%rdx # inp+num*16*$SZ
|
||||
and \$-64,%rsp # align stack frame
|
||||
mov $ctx,$_ctx # save ctx, 1st arg
|
||||
mov $inp,$_inp # save inp, 2nd arh
|
||||
mov %rdx,$_end # save end pointer, "3rd" arg
|
||||
mov %r11,$_rsp # save copy of %rsp
|
||||
.Lprologue:
|
||||
|
||||
mov $SZ*0($ctx),$A
|
||||
mov $SZ*1($ctx),$B
|
||||
mov $SZ*2($ctx),$C
|
||||
mov $SZ*3($ctx),$D
|
||||
mov $SZ*4($ctx),$E
|
||||
mov $SZ*5($ctx),$F
|
||||
mov $SZ*6($ctx),$G
|
||||
mov $SZ*7($ctx),$H
|
||||
jmp .Lloop
|
||||
|
||||
.align 16
|
||||
.Lloop:
|
||||
mov $B,$a3
|
||||
lea $TABLE(%rip),$Tbl
|
||||
xor $C,$a3 # magic
|
||||
___
|
||||
for($i=0;$i<16;$i++) {
|
||||
$code.=" mov $SZ*$i($inp),$T1\n";
|
||||
$code.=" mov @ROT[4],$a0\n";
|
||||
$code.=" mov @ROT[0],$a1\n";
|
||||
$code.=" bswap $T1\n";
|
||||
&ROUND_00_15($i,@ROT);
|
||||
unshift(@ROT,pop(@ROT));
|
||||
}
|
||||
$code.=<<___;
|
||||
jmp .Lrounds_16_xx
|
||||
.align 16
|
||||
.Lrounds_16_xx:
|
||||
___
|
||||
for(;$i<32;$i++) {
|
||||
&ROUND_16_XX($i,@ROT);
|
||||
unshift(@ROT,pop(@ROT));
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
cmpb \$0,`$SZ-1`($Tbl)
|
||||
jnz .Lrounds_16_xx
|
||||
|
||||
mov $_ctx,$ctx
|
||||
add $a1,$A # modulo-scheduled h+=Sigma0(a)
|
||||
lea 16*$SZ($inp),$inp
|
||||
|
||||
add $SZ*0($ctx),$A
|
||||
add $SZ*1($ctx),$B
|
||||
add $SZ*2($ctx),$C
|
||||
add $SZ*3($ctx),$D
|
||||
add $SZ*4($ctx),$E
|
||||
add $SZ*5($ctx),$F
|
||||
add $SZ*6($ctx),$G
|
||||
add $SZ*7($ctx),$H
|
||||
|
||||
cmp $_end,$inp
|
||||
|
||||
mov $A,$SZ*0($ctx)
|
||||
mov $B,$SZ*1($ctx)
|
||||
mov $C,$SZ*2($ctx)
|
||||
mov $D,$SZ*3($ctx)
|
||||
mov $E,$SZ*4($ctx)
|
||||
mov $F,$SZ*5($ctx)
|
||||
mov $G,$SZ*6($ctx)
|
||||
mov $H,$SZ*7($ctx)
|
||||
jb .Lloop
|
||||
|
||||
mov $_rsp,%rsi
|
||||
mov (%rsi),%r15
|
||||
mov 8(%rsi),%r14
|
||||
mov 16(%rsi),%r13
|
||||
mov 24(%rsi),%r12
|
||||
mov 32(%rsi),%rbp
|
||||
mov 40(%rsi),%rbx
|
||||
lea 48(%rsi),%rsp
|
||||
.Lepilogue:
|
||||
ret
|
||||
.size $func,.-$func
|
||||
___
|
||||
|
||||
$code.=<<___;
|
||||
.align 64
|
||||
.type $TABLE,\@object
|
||||
$TABLE:
|
||||
.long 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
|
||||
.long 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
|
||||
.long 0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
|
||||
.long 0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
|
||||
.long 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
|
||||
.long 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
|
||||
.long 0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
|
||||
.long 0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
|
||||
.long 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
|
||||
.long 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
|
||||
.long 0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
|
||||
.long 0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
|
||||
.long 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
|
||||
.long 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
|
||||
.long 0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
|
||||
.long 0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
|
||||
.long 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
|
||||
.long 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
|
||||
.long 0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
|
||||
.long 0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
|
||||
.long 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
|
||||
.long 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
|
||||
.long 0xd192e819,0xd6990624,0xf40e3585,0x106aa070
|
||||
.long 0xd192e819,0xd6990624,0xf40e3585,0x106aa070
|
||||
.long 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
|
||||
.long 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
|
||||
.long 0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
|
||||
.long 0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
|
||||
.long 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
|
||||
.long 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
|
||||
.long 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
|
||||
.long 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
|
||||
|
||||
.long 0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f
|
||||
.long 0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f
|
||||
.long 0x03020100,0x0b0a0908,0xffffffff,0xffffffff
|
||||
.long 0x03020100,0x0b0a0908,0xffffffff,0xffffffff
|
||||
.long 0xffffffff,0xffffffff,0x03020100,0x0b0a0908
|
||||
.long 0xffffffff,0xffffffff,0x03020100,0x0b0a0908
|
||||
___
|
||||
close STDOUT;
|
||||
|
||||
@@ -1,2 +1,13 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=sm3.c sm3_hmac.c
|
||||
SOURCE[../../libcrypto]=\
|
||||
sm3.c {- $target{sm3_asm_src} -}
|
||||
|
||||
GENERATE[sm3-x86_64.s]=asm/sm3-x86_64.pl $(PERLASM_SCHEME)
|
||||
|
||||
BEGINRAW[Makefile(unix)]
|
||||
##### SM3 assembler implementations
|
||||
|
||||
# GNU make "catch all"
|
||||
{- $builddir -}/sm3-%.S: {- $sourcedir -}/asm/sm3-%.pl
|
||||
CC="$(CC)" $(PERL) $< $(PERLASM_SCHEME) $@
|
||||
ENDRAW[Makefile(unix)]
|
||||
|
||||
@@ -50,8 +50,6 @@
|
||||
#include <string.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/sm9.h>
|
||||
#include <openssl/ec_type1.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
#include "sm9_lcl.h"
|
||||
|
||||
|
||||
|
||||
@@ -51,9 +51,11 @@
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/sm9.h>
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/bn_hash.h>
|
||||
#include "../bn/bn_lcl.h"
|
||||
#include "sm9_lcl.h"
|
||||
|
||||
static int BN_hash_to_range(const EVP_MD *md, BIGNUM **bn,
|
||||
const void *s, size_t slen, const BIGNUM *range, BN_CTX *bn_ctx);
|
||||
|
||||
#if 0
|
||||
typedef struct {
|
||||
@@ -231,3 +233,85 @@ int sm9_check_sign_scheme(int nid)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
int BN_hash_to_range(const EVP_MD *md, BIGNUM **bn,
|
||||
const void *s, size_t slen, const BIGNUM *range, BN_CTX *bn_ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *r = NULL;
|
||||
BIGNUM *a = NULL;
|
||||
unsigned char *buf = NULL;
|
||||
size_t buflen, mdlen;
|
||||
int nbytes, rounds, i;
|
||||
|
||||
if (!s || slen <= 0 || !md || !range) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!(*bn)) {
|
||||
if (!(r = BN_new())) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
r = *bn;
|
||||
BN_zero(r);
|
||||
}
|
||||
|
||||
mdlen = EVP_MD_size(md);
|
||||
buflen = mdlen + slen;
|
||||
if (!(buf = OPENSSL_malloc(buflen))) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
memset(buf, 0, mdlen);
|
||||
memcpy(buf + mdlen, s, slen);
|
||||
|
||||
a = BN_new();
|
||||
if (!a) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
nbytes = BN_num_bytes(range);
|
||||
rounds = (nbytes + mdlen - 1)/mdlen;
|
||||
|
||||
if (!bn_expand(r, rounds * mdlen * 8)) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
for (i = 0; i < rounds; i++) {
|
||||
if (!EVP_Digest(buf, buflen, buf, (unsigned int *)&mdlen, md, NULL)) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_EVP_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_bin2bn(buf, mdlen, a)) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_lshift(r, r, mdlen * 8)) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
if (!BN_uadd(r, r, a)) {
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
if (!BN_mod(r, r, range, bn_ctx)) {
|
||||
//BNerr(BN_F_BN_HASH_TO_RANGE, ERR_R_BN_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
*bn = r;
|
||||
ret = 1;
|
||||
end:
|
||||
if (!ret && !(*bn)) {
|
||||
BN_free(r);
|
||||
}
|
||||
BN_free(a);
|
||||
OPENSSL_free(buf);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -51,8 +51,6 @@
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/sm9.h>
|
||||
#include <openssl/ec.h>
|
||||
#include <openssl/ec_type1.h>
|
||||
#include <openssl/bn_gfp2.h>
|
||||
#include "sm9_lcl.h"
|
||||
|
||||
|
||||
|
||||
@@ -1,2 +0,0 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=speck.c
|
||||
@@ -1,198 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
|
||||
#include <openssl/speck.h>
|
||||
#include "speck_lcl.h"
|
||||
|
||||
void speck_set_encrypt_key16(SPECK_TYPE16 const K[SPECK_KEY_LEN16], SPECK_TYPE16 S[SPECK_ROUNDS16])
|
||||
{
|
||||
SPECK_TYPE16 i, b = K[0];
|
||||
SPECK_TYPE16 a[SPECK_KEY_LEN16 - 1];
|
||||
for (i = 0; i < (SPECK_KEY_LEN16 - 1); i++)
|
||||
{
|
||||
a[i] = K[i + 1];
|
||||
}
|
||||
S[0] = b;
|
||||
for (i = 0; i < SPECK_ROUNDS16 - 1; i++) {
|
||||
R16(a[i % (SPECK_KEY_LEN16 - 1)], b, i);
|
||||
S[i + 1] = b;
|
||||
}
|
||||
}
|
||||
|
||||
void speck_set_decrypt_key16(SPECK_TYPE16 const K[SPECK_KEY_LEN16], SPECK_TYPE16 S[SPECK_ROUNDS16])
|
||||
{
|
||||
SPECK_TYPE16 i, b = K[0];
|
||||
SPECK_TYPE16 a[SPECK_KEY_LEN16 - 1];
|
||||
for (i = 0; i < (SPECK_KEY_LEN16 - 1); i++)
|
||||
{
|
||||
a[i] = K[i + 1];
|
||||
}
|
||||
S[0] = b;
|
||||
for (i = 0; i < SPECK_ROUNDS16 - 1; i++) {
|
||||
R16(a[i % (SPECK_KEY_LEN16 - 1)], b, i);
|
||||
S[i + 1] = b;
|
||||
}
|
||||
}
|
||||
|
||||
void speck_encrypt16(SPECK_TYPE16 const pt[2], SPECK_TYPE16 ct[2], SPECK_TYPE16 const K[SPECK_ROUNDS16])
|
||||
{
|
||||
SPECK_TYPE16 i;
|
||||
ct[0] = pt[0]; ct[1] = pt[1];
|
||||
for (i = 0; i < SPECK_ROUNDS16; i++){
|
||||
R16(ct[1], ct[0], K[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void speck_decrypt16(SPECK_TYPE16 const ct[2], SPECK_TYPE16 pt[2], SPECK_TYPE16 const K[SPECK_ROUNDS16])
|
||||
{
|
||||
SPECK_TYPE16 i;
|
||||
pt[0] = ct[0]; pt[1] = ct[1];
|
||||
|
||||
for (i = 0; i < SPECK_ROUNDS16; i++){
|
||||
RR16(pt[1], pt[0], K[(SPECK_ROUNDS16 - 1) - i]);
|
||||
}
|
||||
}
|
||||
|
||||
void speck_set_encrypt_key32(SPECK_TYPE32 const K[SPECK_KEY_LEN32], SPECK_TYPE32 S[SPECK_ROUNDS32])
|
||||
{
|
||||
SPECK_TYPE32 i, b = K[0];
|
||||
SPECK_TYPE32 a[SPECK_KEY_LEN32 - 1];
|
||||
for (i = 0; i < (SPECK_KEY_LEN32 - 1); i++)
|
||||
{
|
||||
a[i] = K[i + 1];
|
||||
}
|
||||
S[0] = b;
|
||||
for (i = 0; i < SPECK_ROUNDS32 - 1; i++) {
|
||||
R32(a[i % (SPECK_KEY_LEN32 - 1)], b, i);
|
||||
S[i + 1] = b;
|
||||
}
|
||||
}
|
||||
|
||||
void speck_set_decrypt_key32(SPECK_TYPE32 const K[SPECK_KEY_LEN32], SPECK_TYPE32 S[SPECK_ROUNDS32])
|
||||
{
|
||||
SPECK_TYPE32 i, b = K[0];
|
||||
SPECK_TYPE32 a[SPECK_KEY_LEN32 - 1];
|
||||
for (i = 0; i < (SPECK_KEY_LEN32 - 1); i++)
|
||||
{
|
||||
a[i] = K[i + 1];
|
||||
}
|
||||
S[0] = b;
|
||||
for (i = 0; i < SPECK_ROUNDS32 - 1; i++) {
|
||||
R32(a[i % (SPECK_KEY_LEN32 - 1)], b, i);
|
||||
S[i + 1] = b;
|
||||
}
|
||||
}
|
||||
|
||||
void speck_encrypt32(SPECK_TYPE32 const pt[2], SPECK_TYPE32 ct[2], SPECK_TYPE32 const K[SPECK_ROUNDS32])
|
||||
{
|
||||
SPECK_TYPE32 i;
|
||||
ct[0] = pt[0]; ct[1] = pt[1];
|
||||
for (i = 0; i < SPECK_ROUNDS32; i++){
|
||||
R32(ct[1], ct[0], K[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void speck_decrypt32(SPECK_TYPE32 const ct[2], SPECK_TYPE32 pt[2], SPECK_TYPE32 const K[SPECK_ROUNDS32])
|
||||
{
|
||||
SPECK_TYPE32 i;
|
||||
pt[0] = ct[0]; pt[1] = ct[1];
|
||||
|
||||
for (i = 0; i < SPECK_ROUNDS32; i++){
|
||||
RR32(pt[1], pt[0], K[(SPECK_ROUNDS32 - 1) - i]);
|
||||
}
|
||||
}
|
||||
|
||||
void speck_set_encrypt_key64(SPECK_TYPE64 const K[SPECK_KEY_LEN64], SPECK_TYPE64 S[SPECK_ROUNDS64])
|
||||
{
|
||||
SPECK_TYPE64 i, b = K[0];
|
||||
SPECK_TYPE64 a[SPECK_KEY_LEN64 - 1];
|
||||
for (i = 0; i < (SPECK_KEY_LEN64 - 1); i++)
|
||||
{
|
||||
a[i] = K[i + 1];
|
||||
}
|
||||
S[0] = b;
|
||||
for (i = 0; i < SPECK_ROUNDS64 - 1; i++) {
|
||||
R64(a[i % (SPECK_KEY_LEN64 - 1)], b, i);
|
||||
S[i + 1] = b;
|
||||
}
|
||||
}
|
||||
|
||||
void speck_set_decrypt_key64(SPECK_TYPE64 const K[SPECK_KEY_LEN64], SPECK_TYPE64 S[SPECK_ROUNDS64])
|
||||
{
|
||||
SPECK_TYPE64 i, b = K[0];
|
||||
SPECK_TYPE64 a[SPECK_KEY_LEN64 - 1];
|
||||
for (i = 0; i < (SPECK_KEY_LEN64 - 1); i++)
|
||||
{
|
||||
a[i] = K[i + 1];
|
||||
}
|
||||
S[0] = b;
|
||||
for (i = 0; i < SPECK_ROUNDS64 - 1; i++) {
|
||||
R64(a[i % (SPECK_KEY_LEN64 - 1)], b, i);
|
||||
S[i + 1] = b;
|
||||
}
|
||||
}
|
||||
|
||||
void speck_encrypt64(SPECK_TYPE64 const pt[2], SPECK_TYPE64 ct[2], SPECK_TYPE64 const K[SPECK_ROUNDS64])
|
||||
{
|
||||
SPECK_TYPE64 i;
|
||||
ct[0] = pt[0]; ct[1] = pt[1];
|
||||
for (i = 0; i < SPECK_ROUNDS64; i++){
|
||||
R64(ct[1], ct[0], K[i]);
|
||||
}
|
||||
}
|
||||
|
||||
void speck_decrypt64(SPECK_TYPE64 const ct[2], SPECK_TYPE64 pt[2], SPECK_TYPE64 const K[SPECK_ROUNDS64])
|
||||
{
|
||||
SPECK_TYPE64 i;
|
||||
pt[0] = ct[0]; pt[1] = ct[1];
|
||||
|
||||
for (i = 0; i < SPECK_ROUNDS64; i++){
|
||||
RR64(pt[1], pt[0], K[(SPECK_ROUNDS64 - 1) - i]);
|
||||
}
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
/* ====================================================================
|
||||
* Copyright (c) 2014 - 2017 The GmSSL Project. All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
*
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in
|
||||
* the documentation and/or other materials provided with the
|
||||
* distribution.
|
||||
*
|
||||
* 3. All advertising materials mentioning features or use of this
|
||||
* software must display the following acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project.
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* 4. The name "GmSSL Project" must not be used to endorse or promote
|
||||
* products derived from this software without prior written
|
||||
* permission. For written permission, please contact
|
||||
* guanzhi1980@gmail.com.
|
||||
*
|
||||
* 5. Products derived from this software may not be called "GmSSL"
|
||||
* nor may "GmSSL" appear in their names without prior written
|
||||
* permission of the GmSSL Project.
|
||||
*
|
||||
* 6. Redistributions of any form whatsoever must retain the following
|
||||
* acknowledgment:
|
||||
* "This product includes software developed by the GmSSL Project
|
||||
* (http://gmssl.org/)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE GmSSL PROJECT ``AS IS'' AND ANY
|
||||
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE GmSSL PROJECT OR
|
||||
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
||||
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
* ====================================================================
|
||||
*/
|
||||
#ifndef HEADER_SPECK_LCL_H
|
||||
#define HEADER_SPECK_LCL_H
|
||||
|
||||
#define SPECK_TYPE16 uint16_t
|
||||
#define SPECK_TYPE32 uint32_t
|
||||
#define SPECK_TYPE64 uint64_t
|
||||
|
||||
#define ROR16(x, r) ((x >> r) | (x << ((sizeof(SPECK_TYPE16) * 8) - r)))
|
||||
#define ROL16(x, r) ((x << r) | (x >> ((sizeof(SPECK_TYPE16) * 8) - r)))
|
||||
|
||||
#define ROR32(x, r) ((x >> r) | (x << ((sizeof(SPECK_TYPE32) * 8) - r)))
|
||||
#define ROL32(x, r) ((x << r) | (x >> ((sizeof(SPECK_TYPE32) * 8) - r)))
|
||||
|
||||
#define ROR64(x, r) ((x >> r) | (x << ((sizeof(SPECK_TYPE64) * 8) - r)))
|
||||
#define ROL64(x, r) ((x << r) | (x >> ((sizeof(SPECK_TYPE64) * 8) - r)))
|
||||
|
||||
#define R16(x, y, k) (x = ROR16(x, 7), x += y, x ^= k, y = ROL16(y, 2), y ^= x)
|
||||
#define RR16(x, y, k) (y ^= x, y = ROR16(y, 2), x ^= k, x -= y, x = ROL16(x, 7))
|
||||
|
||||
#define R32(x, y, k) (x = ROR32(x, 8), x += y, x ^= k, y = ROL32(y, 3), y ^= x)
|
||||
#define RR32(x, y, k) (y ^= x, y = ROR32(y, 3), x ^= k, x -= y, x = ROL32(x, 8))
|
||||
|
||||
#define R64(x, y, k) (x = ROR64(x, 8), x += y, x ^= k, y = ROL64(y, 3), y ^= x)
|
||||
#define RR64(x, y, k) (y ^= x, y = ROR64(y, 3), x ^= k, x -= y, x = ROL64(x, 8))
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user