Update OpenSSL-1.1.1-pre9-dev
This commit is contained in:
@@ -8,8 +8,13 @@
|
||||
release branch.
|
||||
|
||||
Changes between 1.1.0h and 1.1.1 [xx XXX xxxx]
|
||||
*) Add blinding to an ECDSA signature to protect against side channel attacks
|
||||
discovered by Keegan Ryan (NCC Group).
|
||||
*) Add coordinate blinding for EC_POINT and implement projective
|
||||
coordinate blinding for generic prime curves as a countermeasure to
|
||||
chosen point SCA attacks.
|
||||
[Sohaib ul Hassan, Nicola Tuveri, Billy Bob Brumley]
|
||||
|
||||
*) Add blinding to ECDSA and DSA signatures to protect against side channel
|
||||
attacks discovered by Keegan Ryan (NCC Group).
|
||||
[Matt Caswell]
|
||||
|
||||
*) Enforce checking in the pkeyutl command line app to ensure that the input
|
||||
|
||||
+20
-35
@@ -356,75 +356,60 @@ my %targets = (
|
||||
|
||||
#### IRIX 6.x configs
|
||||
# Only N32 and N64 ABIs are supported.
|
||||
"irix-mips3-gcc" => {
|
||||
inherit_from => [ "BASE_unix", asm("mips64_asm") ],
|
||||
CC => "gcc",
|
||||
CFLAGS => picker(debug => "-g -O0",
|
||||
release => "-O3"),
|
||||
cflags => "-mabi=n32",
|
||||
cppflags => combine("-DB_ENDIAN -DBN_DIV3W",
|
||||
threads("-D_SGI_MP_SOURCE")),
|
||||
"irix-common" => {
|
||||
inherit_from => [ "BASE_unix" ],
|
||||
template => 1,
|
||||
cppflags => threads("-D_SGI_MP_SOURCE"),
|
||||
lib_cppflags => "-DB_ENDIAN -DBN_DIV3W",
|
||||
ex_libs => add(threads("-lpthread")),
|
||||
bn_ops => "RC4_CHAR SIXTY_FOUR_BIT",
|
||||
thread_scheme => "pthreads",
|
||||
perlasm_scheme => "n32",
|
||||
dso_scheme => "dlfcn",
|
||||
shared_target => "irix-shared",
|
||||
shared_target => "self",
|
||||
shared_extension => ".so.\$(SHLIB_VERSION_NUMBER)",
|
||||
shared_ldflag => "-shared -Wl,-Bsymbolic",
|
||||
shared_sonameflag=> "-Wl,-soname,",
|
||||
},
|
||||
"irix-mips3-gcc" => {
|
||||
inherit_from => [ "irix-common", asm("mips64_asm") ],
|
||||
CC => "gcc",
|
||||
CFLAGS => picker(debug => "-g -O0",
|
||||
release => "-O3"),
|
||||
LDFLAGS => "-static-libgcc",
|
||||
cflags => "-mabi=n32",
|
||||
bn_ops => "RC4_CHAR SIXTY_FOUR_BIT",
|
||||
perlasm_scheme => "n32",
|
||||
multilib => "32",
|
||||
},
|
||||
"irix-mips3-cc" => {
|
||||
inherit_from => [ "BASE_unix", asm("mips64_asm") ],
|
||||
inherit_from => [ "irix-common", asm("mips64_asm") ],
|
||||
CC => "cc",
|
||||
CFLAGS => picker(debug => "-g -O0",
|
||||
release => "-O2"),
|
||||
cflags => "-n32 -mips3 -use_readonly_const -G0 -rdata_shared",
|
||||
cppflags => threads("-D_SGI_MP_SOURCE"),
|
||||
lib_cppflags => "-DB_ENDIAN -DBN_DIV3W",
|
||||
ex_libs => add(threads("-lpthread")),
|
||||
bn_ops => "RC4_CHAR SIXTY_FOUR_BIT",
|
||||
thread_scheme => "pthreads",
|
||||
perlasm_scheme => "n32",
|
||||
dso_scheme => "dlfcn",
|
||||
shared_target => "irix-shared",
|
||||
shared_extension => ".so.\$(SHLIB_VERSION_NUMBER)",
|
||||
multilib => "32",
|
||||
},
|
||||
# N64 ABI builds.
|
||||
"irix64-mips4-gcc" => {
|
||||
inherit_from => [ "BASE_unix", asm("mips64_asm") ],
|
||||
inherit_from => [ "irix-common", asm("mips64_asm") ],
|
||||
CC => "gcc",
|
||||
CFLAGS => picker(debug => "-g -O0",
|
||||
release => "-O3"),
|
||||
LDFLAGS => "-static-libgcc",
|
||||
cflags => "-mabi=64 -mips4",
|
||||
cppflags => threads("-D_SGI_MP_SOURCE"),
|
||||
lib_cppflags => "-DB_ENDIAN -DBN_DIV3W",
|
||||
ex_libs => add(threads("-lpthread")),
|
||||
bn_ops => "RC4_CHAR SIXTY_FOUR_BIT_LONG",
|
||||
thread_scheme => "pthreads",
|
||||
perlasm_scheme => "64",
|
||||
dso_scheme => "dlfcn",
|
||||
shared_target => "irix-shared",
|
||||
shared_extension => ".so.\$(SHLIB_VERSION_NUMBER)",
|
||||
multilib => "64",
|
||||
},
|
||||
"irix64-mips4-cc" => {
|
||||
inherit_from => [ "BASE_unix", asm("mips64_asm") ],
|
||||
inherit_from => [ "irix-common", asm("mips64_asm") ],
|
||||
CC => "cc",
|
||||
CFLAGS => picker(debug => "-g -O0",
|
||||
release => "-O2"),
|
||||
cflags => "-64 -mips4 -use_readonly_const -G0 -rdata_shared",
|
||||
cppflags => threads("-D_SGI_MP_SOURCE"),
|
||||
lib_cppflags => "-DB_ENDIAN -DBN_DIV3W",
|
||||
ex_libs => threads("-lpthread"),
|
||||
bn_ops => "RC4_CHAR SIXTY_FOUR_BIT_LONG",
|
||||
thread_scheme => "pthreads",
|
||||
perlasm_scheme => "64",
|
||||
dso_scheme => "dlfcn",
|
||||
shared_target => "irix-shared",
|
||||
shared_extension => ".so.\$(SHLIB_VERSION_NUMBER)",
|
||||
multilib => "64",
|
||||
},
|
||||
|
||||
|
||||
@@ -79,11 +79,4 @@ my %shared_info;
|
||||
shared_sonameflag => '-h ',
|
||||
};
|
||||
},
|
||||
'irix-shared' => sub {
|
||||
return $shared_info{'gnu-shared'} if detect_gnu_ld();
|
||||
return {
|
||||
shared_ldflag => '-shared -Wl,-Bsymbolic',
|
||||
shared_sonameflag => '-Wl,-soname=',
|
||||
};
|
||||
},
|
||||
);
|
||||
@@ -708,9 +708,11 @@ update: generate errors ordinals
|
||||
generate: generate_apps generate_crypto_bn generate_crypto_objects \
|
||||
generate_crypto_conf generate_crypto_asn1 generate_fuzz_oids
|
||||
|
||||
.PHONY: doc-nits
|
||||
doc-nits:
|
||||
(cd $(SRCDIR); $(PERL) util/find-doc-nits -n -p ) >doc-nits
|
||||
if [ -s doc-nits ] ; then cat doc-nits; rm doc-nits ; exit 1; fi
|
||||
@if [ -s doc-nits ] ; then cat doc-nits ; exit 1; \
|
||||
else echo 'doc-nits: no errors.'; rm doc-nits ; fi
|
||||
|
||||
# Test coverage is a good idea for the future
|
||||
#coverage: $(PROGRAMS) $(TESTPROGRAMS)
|
||||
|
||||
@@ -548,9 +548,9 @@
|
||||
Build without support for the specified algorithm, where
|
||||
<alg> is one of: aria, bf, blake2, camellia, cast, chacha,
|
||||
cmac, des, dh, dsa, ecdh, ecdsa, idea, md4, mdc2, ocb,
|
||||
poly1305, rc2, rc4, rmd160, scrypt, seed, siphash, sm3, sm4
|
||||
or whirlpool. The "ripemd" algorithm is deprecated and if
|
||||
used is synonymous with rmd160.
|
||||
poly1305, rc2, rc4, rmd160, scrypt, seed, siphash, sm2, sm3,
|
||||
sm4 or whirlpool. The "ripemd" algorithm is deprecated and
|
||||
if used is synonymous with rmd160.
|
||||
|
||||
-Dxxx, -Ixxx, -Wp, -lxxx, -Lxxx, -Wl, -rpath, -R, -framework, -static
|
||||
These system specific options will be recognised and
|
||||
|
||||
+78
-29
@@ -5,38 +5,87 @@
|
||||
For Unix/POSIX runtime systems on Windows, please see NOTES.WIN.
|
||||
|
||||
|
||||
Shared libraries and installation in non-standard locations
|
||||
-----------------------------------------------------------
|
||||
OpenSSL uses the compiler to link programs and shared libraries
|
||||
---------------------------------------------------------------
|
||||
|
||||
Binaries on Unix variants expect to find shared libraries in standard
|
||||
locations, such as /usr/lib, /usr/local/lib and some other locations
|
||||
configured in the system (for example /etc/ld.so.conf on some systems).
|
||||
If the libraries are installed in non-standard locations, binaries
|
||||
will not find them and therefore fail to run unless they get a bit of
|
||||
help from a defined RPATH or RUNPATH. This can be applied by adding
|
||||
the appropriate linker flags to the configuration command, such as
|
||||
this (/usr/local/ssl was the default location for OpenSSL installation
|
||||
in versions before 1.1.0):
|
||||
OpenSSL's generated Makefile uses the C compiler command line to
|
||||
link programs, shared libraries and dynamically loadable shared
|
||||
objects. Because of this, any linking option that's given to the
|
||||
configuration scripts MUST be in a form that the compiler can accept.
|
||||
This varies between systems, where some have compilers that accept
|
||||
linker flags directly, while others take them in '-Wl,' form. You need
|
||||
to read your compiler documentation to figure out what is acceptable,
|
||||
and ld(1) to figure out what linker options are available.
|
||||
|
||||
|
||||
Shared libraries and installation in non-default locations
|
||||
----------------------------------------------------------
|
||||
|
||||
Every Unix system has its own set of default locations for shared
|
||||
libraries, such as /lib, /usr/lib or possibly /usr/local/lib. If
|
||||
libraries are installed in non-default locations, dynamically linked
|
||||
binaries will not find them and therefore fail to run unless they get a
|
||||
bit of help from a defined runtime shared library search path.
|
||||
|
||||
For OpenSSL's application (the 'openssl' command), our configuration
|
||||
scripts do NOT generally set the runtime shared library search path for
|
||||
you. It's therefore advisable to set it explicitly when configuring
|
||||
unless the libraries are to be installed in directories that you know
|
||||
to be in the default list.
|
||||
|
||||
Runtime shared library search paths are specified with different
|
||||
linking options depending on operating system and versions thereof, and
|
||||
are talked about differently in their respective documentation;
|
||||
variations of RPATH are the most usual (note: ELF systems have two such
|
||||
tags, more on that below).
|
||||
|
||||
Possible options to set the runtime shared library search path include
|
||||
the following:
|
||||
|
||||
-Wl,-rpath,/whatever/path
|
||||
-R /whatever/path
|
||||
-rpath /whatever/path
|
||||
|
||||
OpenSSL's configuration scripts recognise all these options and pass
|
||||
them to the Makefile that they build. (In fact, it recognises anything
|
||||
starting with '-Wl,' as a linker option, so for example, HP-UX'
|
||||
'-Wl,+b,/whatever/path' would be used correctly)
|
||||
|
||||
Please do not use verbatim directories in your runtime shared library
|
||||
search path! Some OpenSSL config targets add an extra directory level
|
||||
for multilib installations. To help with that, the produced Makefile
|
||||
includes the variable LIBRPATH, which is a convenience variable to be
|
||||
used with the runtime shared library search path options, as shown in
|
||||
this example:
|
||||
|
||||
$ ./config --prefix=/usr/local/ssl --openssldir=/usr/local/ssl \
|
||||
-Wl,-rpath,/usr/local/ssl/lib
|
||||
'-Wl,-rpath,$(LIBRPATH)'
|
||||
|
||||
Because the actual library location may vary further (for example on
|
||||
multilib installations), there is a convenience variable in Makefile
|
||||
that holds the exact installation directory and that can be used like
|
||||
this:
|
||||
On modern ELF based systems, there are two runtime search paths tags to
|
||||
consider, DT_RPATH and DT_RUNPATH. Shared objects are searched for in
|
||||
this order:
|
||||
|
||||
1. Using directories specified in DT_RPATH, unless DT_RUNPATH is
|
||||
also set.
|
||||
2. Using the environment variable LD_LIBRARY_PATH
|
||||
3. Using directories specified in DT_RUNPATH.
|
||||
4. Using system shared object caches and default directories.
|
||||
|
||||
This means that the values in the environment variable LD_LIBRARY_PATH
|
||||
won't matter if the library is found in the paths given by DT_RPATH
|
||||
(and DT_RUNPATH isn't set).
|
||||
|
||||
Exactly which of DT_RPATH or DT_RUNPATH is set by default appears to
|
||||
depend on the system. For example, according to documentation,
|
||||
DT_RPATH appears to be deprecated on Solaris in favor of DT_RUNPATH,
|
||||
while on Debian GNU/Linux, either can be set, and DT_RPATH is the
|
||||
default at the time of writing.
|
||||
|
||||
How to choose which runtime search path tag is to be set depends on
|
||||
your system, please refer to ld(1) for the exact information on your
|
||||
system. As an example, the way to ensure the DT_RUNPATH is set on
|
||||
Debian GNU/Linux systems rather than DT_RPATH is to tell the linker to
|
||||
set new dtags, like this:
|
||||
|
||||
$ ./config --prefix=/usr/local/ssl --openssldir=/usr/local/ssl \
|
||||
-Wl,-rpath,'$(LIBRPATH)'
|
||||
|
||||
On modern systems using GNU ld.so, a better choice may be to use the
|
||||
new dtags, like this:
|
||||
|
||||
$ ./config --prefix=/usr/local/ssl --openssldir=/usr/local/ssl \
|
||||
-Wl,--enable-new-dtags,-rpath,'$(LIBRPATH)'
|
||||
|
||||
This sets DT_RUNPATH instead of DT_RPATH. DT_RUNPATH is considered after
|
||||
the environment variable LD_LIBRARY_PATH, while DT_RPATH is considered
|
||||
before that environment variable (which means that the values in that
|
||||
environment variable won't matter if the library is found in the
|
||||
paths given by DT_RPATH).
|
||||
'-Wl,--enable-new-dtags,-rpath,$(LIBRPATH)'
|
||||
@@ -1,5 +1,5 @@
|
||||
|
||||
OpenSSL 1.1.1-pre8-dev
|
||||
OpenSSL 1.1.1-pre9-dev
|
||||
|
||||
Copyright (c) 1998-2018 The OpenSSL Project
|
||||
Copyright (c) 1995-1998 Eric A. Young, Tim J. Hudson
|
||||
|
||||
@@ -726,10 +726,6 @@ end_of_options:
|
||||
output_der = 1;
|
||||
batch = 1;
|
||||
}
|
||||
Sout = bio_open_default(outfile, 'w',
|
||||
output_der ? FORMAT_ASN1 : FORMAT_TEXT);
|
||||
if (Sout == NULL)
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (md == NULL && (md = lookup_conf(conf, section, ENV_DEFAULT_MD)) == NULL)
|
||||
@@ -1025,6 +1021,11 @@ end_of_options:
|
||||
if (verbose)
|
||||
BIO_printf(bio_err, "writing %s\n", new_cert);
|
||||
|
||||
Sout = bio_open_default(outfile, 'w',
|
||||
output_der ? FORMAT_ASN1 : FORMAT_TEXT);
|
||||
if (Sout == NULL)
|
||||
goto end;
|
||||
|
||||
Cout = BIO_new_file(new_cert, "w");
|
||||
if (Cout == NULL) {
|
||||
perror(new_cert);
|
||||
@@ -1033,6 +1034,8 @@ end_of_options:
|
||||
write_new_certificate(Cout, xi, 0, notext);
|
||||
write_new_certificate(Sout, xi, output_der, notext);
|
||||
BIO_free_all(Cout);
|
||||
BIO_free_all(Sout);
|
||||
Sout = NULL;
|
||||
}
|
||||
|
||||
if (sk_X509_num(cert_sk)) {
|
||||
@@ -1181,6 +1184,11 @@ end_of_options:
|
||||
if (!do_X509_CRL_sign(crl, pkey, dgst, sigopts))
|
||||
goto end;
|
||||
|
||||
Sout = bio_open_default(outfile, 'w',
|
||||
output_der ? FORMAT_ASN1 : FORMAT_TEXT);
|
||||
if (Sout == NULL)
|
||||
goto end;
|
||||
|
||||
PEM_write_bio_X509_CRL(Sout, crl);
|
||||
|
||||
if (crlnumberfile != NULL) /* Rename the crlnumber file */
|
||||
|
||||
@@ -120,6 +120,13 @@ int genpkey_main(int argc, char **argv)
|
||||
if (!opt_cipher(opt_unknown(), &cipher)
|
||||
|| do_param == 1)
|
||||
goto opthelp;
|
||||
if (EVP_CIPHER_mode(cipher) == EVP_CIPH_GCM_MODE ||
|
||||
EVP_CIPHER_mode(cipher) == EVP_CIPH_CCM_MODE ||
|
||||
EVP_CIPHER_mode(cipher) == EVP_CIPH_XTS_MODE ||
|
||||
EVP_CIPHER_mode(cipher) == EVP_CIPH_OCB_MODE) {
|
||||
BIO_printf(bio_err, "%s: cipher mode not supported\n", prog);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
}
|
||||
argc = opt_num_rest();
|
||||
|
||||
@@ -322,6 +322,8 @@ static const ERR_STRING_DATA ASN1_str_reasons[] = {
|
||||
{ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNKNOWN_TAG), "unknown tag"},
|
||||
{ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE),
|
||||
"unsupported any defined by type"},
|
||||
{ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_CIPHER),
|
||||
"unsupported cipher"},
|
||||
{ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE),
|
||||
"unsupported public key type"},
|
||||
{ERR_PACK(ERR_LIB_ASN1, 0, ASN1_R_UNSUPPORTED_TYPE), "unsupported type"},
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 1999-2018 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
|
||||
@@ -78,7 +78,7 @@ X509_ALGOR *PKCS5_pbe2_set_iv(const EVP_CIPHER *cipher, int iter,
|
||||
/* Dummy cipherinit to just setup the IV, and PRF */
|
||||
if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, iv, 0))
|
||||
goto err;
|
||||
if (EVP_CIPHER_param_to_asn1(ctx, scheme->parameter) < 0) {
|
||||
if (EVP_CIPHER_param_to_asn1(ctx, scheme->parameter) <= 0) {
|
||||
ASN1err(ASN1_F_PKCS5_PBE2_SET_IV, ASN1_R_ERROR_SETTING_CIPHER_PARAMS);
|
||||
goto err;
|
||||
}
|
||||
|
||||
@@ -93,7 +93,7 @@ X509_ALGOR *PKCS5_pbe2_set_scrypt(const EVP_CIPHER *cipher,
|
||||
/* Dummy cipherinit to just setup the IV */
|
||||
if (EVP_CipherInit_ex(ctx, cipher, NULL, NULL, iv, 0) == 0)
|
||||
goto err;
|
||||
if (EVP_CIPHER_param_to_asn1(ctx, scheme->parameter) < 0) {
|
||||
if (EVP_CIPHER_param_to_asn1(ctx, scheme->parameter) <= 0) {
|
||||
ASN1err(ASN1_F_PKCS5_PBE2_SET_SCRYPT,
|
||||
ASN1_R_ERROR_SETTING_CIPHER_PARAMS);
|
||||
goto err;
|
||||
|
||||
@@ -54,5 +54,8 @@ static const EVP_PKEY_ASN1_METHOD *standard_methods[] = {
|
||||
&ed25519_asn1_meth,
|
||||
&ed448_asn1_meth,
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_SM2
|
||||
&sm2_asn1_meth,
|
||||
#endif
|
||||
};
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#! /usr/bin/env perl
|
||||
# Copyright 2013-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright 2013-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright (c) 2012, Intel Corporation. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the OpenSSL license (the "License"). You may not use
|
||||
@@ -66,7 +66,7 @@ if (!$avx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
|
||||
$addx = ($1>=11);
|
||||
}
|
||||
|
||||
if (!$avx && `$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9])\.([0-9]+)/) {
|
||||
if (!$avx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|based on LLVM) ([3-9])\.([0-9]+)/) {
|
||||
my $ver = $2 + $3/100.0; # 3.1->3.01, 3.10->3.10
|
||||
$avx = ($ver>=3.0) + ($ver>=3.01);
|
||||
$addx = ($ver>=3.03);
|
||||
|
||||
@@ -44,51 +44,11 @@
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
/* 32-bit rotations */
|
||||
#if !defined(PEDANTIC) && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
|
||||
# if defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_AMD64) || defined(_M_X64))
|
||||
# define RightRotate(x, s) _lrotr(x, s)
|
||||
# define LeftRotate(x, s) _lrotl(x, s)
|
||||
# if _MSC_VER >= 1400
|
||||
# define SWAP(x) _byteswap_ulong(x)
|
||||
# else
|
||||
# define SWAP(x) (_lrotl(x, 8) & 0x00ff00ff | _lrotr(x, 8) & 0xff00ff00)
|
||||
# endif
|
||||
# define GETU32(p) SWAP(*((u32 *)(p)))
|
||||
# define PUTU32(p,v) (*((u32 *)(p)) = SWAP((v)))
|
||||
# elif defined(__GNUC__) && __GNUC__>=2
|
||||
# if defined(__i386) || defined(__x86_64)
|
||||
# define RightRotate(x,s) ({u32 ret; asm ("rorl %1,%0":"=r"(ret):"I"(s),"0"(x):"cc"); ret; })
|
||||
# define LeftRotate(x,s) ({u32 ret; asm ("roll %1,%0":"=r"(ret):"I"(s),"0"(x):"cc"); ret; })
|
||||
# if defined(B_ENDIAN) /* stratus.com does it */
|
||||
# define GETU32(p) (*(u32 *)(p))
|
||||
# define PUTU32(p,v) (*(u32 *)(p)=(v))
|
||||
# else
|
||||
# define GETU32(p) ({u32 r=*(const u32 *)(p); asm("bswapl %0":"=r"(r):"0"(r)); r; })
|
||||
# define PUTU32(p,v) ({u32 r=(v); asm("bswapl %0":"=r"(r):"0"(r)); *(u32 *)(p)=r; })
|
||||
# endif
|
||||
# elif defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
|
||||
defined(__powerpc) || defined(__ppc__) || defined(__powerpc64__)
|
||||
# define LeftRotate(x,s) ({u32 ret; asm ("rlwinm %0,%1,%2,0,31":"=r"(ret):"r"(x),"I"(s)); ret; })
|
||||
# define RightRotate(x,s) LeftRotate(x,(32-s))
|
||||
# elif defined(__s390x__)
|
||||
# define LeftRotate(x,s) ({u32 ret; asm ("rll %0,%1,%2":"=r"(ret):"r"(x),"I"(s)); ret; })
|
||||
# define RightRotate(x,s) LeftRotate(x,(32-s))
|
||||
# define GETU32(p) (*(u32 *)(p))
|
||||
# define PUTU32(p,v) (*(u32 *)(p)=(v))
|
||||
# endif
|
||||
# endif
|
||||
#endif
|
||||
#define RightRotate(x, s) ( ((x) >> (s)) + ((x) << (32 - s)) )
|
||||
#define LeftRotate(x, s) ( ((x) << (s)) + ((x) >> (32 - s)) )
|
||||
|
||||
#if !defined(RightRotate) && !defined(LeftRotate)
|
||||
# define RightRotate(x, s) ( ((x) >> (s)) + ((x) << (32 - s)) )
|
||||
# define LeftRotate(x, s) ( ((x) << (s)) + ((x) >> (32 - s)) )
|
||||
#endif
|
||||
|
||||
#if !defined(GETU32) && !defined(PUTU32)
|
||||
# define GETU32(p) (((u32)(p)[0] << 24) ^ ((u32)(p)[1] << 16) ^ ((u32)(p)[2] << 8) ^ ((u32)(p)[3]))
|
||||
# define PUTU32(p,v) ((p)[0] = (u8)((v) >> 24), (p)[1] = (u8)((v) >> 16), (p)[2] = (u8)((v) >> 8), (p)[3] = (u8)(v))
|
||||
#endif
|
||||
#define GETU32(p) (((u32)(p)[0] << 24) ^ ((u32)(p)[1] << 16) ^ ((u32)(p)[2] << 8) ^ ((u32)(p)[3]))
|
||||
#define PUTU32(p,v) ((p)[0] = (u8)((v) >> 24), (p)[1] = (u8)((v) >> 16), (p)[2] = (u8)((v) >> 8), (p)[3] = (u8)(v))
|
||||
|
||||
/* S-box data */
|
||||
#define SBOX1_1110 Camellia_SBOX[0]
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#! /usr/bin/env perl
|
||||
# Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright 2016-2018 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
|
||||
@@ -62,7 +62,7 @@ $ymm=1 if ($xmm && !$ymm && $ARGV[0] eq "win32" &&
|
||||
$1>=10); # first version supporting AVX
|
||||
|
||||
$ymm=1 if ($xmm && !$ymm &&
|
||||
`$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9]\.[0-9]+)/ &&
|
||||
`$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|based on LLVM) ([3-9]\.[0-9]+)/ &&
|
||||
$2>=3.0); # first version supporting AVX
|
||||
|
||||
$a="eax";
|
||||
|
||||
@@ -326,7 +326,7 @@ int cms_RecipientInfo_pwri_crypt(CMS_ContentInfo *cms, CMS_RecipientInfo *ri,
|
||||
if (!EVP_CipherInit_ex(kekctx, kekcipher, NULL, NULL, NULL, en_de))
|
||||
goto err;
|
||||
EVP_CIPHER_CTX_set_padding(kekctx, 0);
|
||||
if (EVP_CIPHER_asn1_to_param(kekctx, kekalg->parameter) < 0) {
|
||||
if (EVP_CIPHER_asn1_to_param(kekctx, kekalg->parameter) <= 0) {
|
||||
CMSerr(CMS_F_CMS_RECIPIENTINFO_PWRI_CRYPT,
|
||||
CMS_R_CIPHER_PARAMETER_INITIALISATION_ERROR);
|
||||
goto err;
|
||||
|
||||
+1
-1
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 1995-2018 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
|
||||
|
||||
+49
-17
@@ -59,19 +59,13 @@ const DSA_METHOD *DSA_OpenSSL(void)
|
||||
static DSA_SIG *dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
|
||||
{
|
||||
BIGNUM *kinv = NULL;
|
||||
BIGNUM *m;
|
||||
BIGNUM *xr;
|
||||
BIGNUM *m, *blind, *blindm, *tmp;
|
||||
BN_CTX *ctx = NULL;
|
||||
int reason = ERR_R_BN_LIB;
|
||||
DSA_SIG *ret = NULL;
|
||||
int rv = 0;
|
||||
|
||||
m = BN_new();
|
||||
xr = BN_new();
|
||||
if (m == NULL || xr == NULL)
|
||||
goto err;
|
||||
|
||||
if (!dsa->p || !dsa->q || !dsa->g) {
|
||||
if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL) {
|
||||
reason = DSA_R_MISSING_PARAMETERS;
|
||||
goto err;
|
||||
}
|
||||
@@ -87,6 +81,13 @@ static DSA_SIG *dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
|
||||
ctx = BN_CTX_new();
|
||||
if (ctx == NULL)
|
||||
goto err;
|
||||
m = BN_CTX_get(ctx);
|
||||
blind = BN_CTX_get(ctx);
|
||||
blindm = BN_CTX_get(ctx);
|
||||
tmp = BN_CTX_get(ctx);
|
||||
if (tmp == NULL)
|
||||
goto err;
|
||||
|
||||
redo:
|
||||
if (!dsa_sign_setup(dsa, ctx, &kinv, &ret->r, dgst, dlen))
|
||||
goto err;
|
||||
@@ -101,17 +102,50 @@ static DSA_SIG *dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
|
||||
if (BN_bin2bn(dgst, dlen, m) == NULL)
|
||||
goto err;
|
||||
|
||||
/* Compute s = inv(k) (m + xr) mod q */
|
||||
if (!BN_mod_mul(xr, dsa->priv_key, ret->r, dsa->q, ctx))
|
||||
goto err; /* s = xr */
|
||||
if (!BN_add(ret->s, xr, m))
|
||||
goto err; /* s = m + xr */
|
||||
if (BN_cmp(ret->s, dsa->q) > 0)
|
||||
if (!BN_sub(ret->s, ret->s, dsa->q))
|
||||
/*
|
||||
* The normal signature calculation is:
|
||||
*
|
||||
* s := k^-1 * (m + r * priv_key) mod q
|
||||
*
|
||||
* We will blind this to protect against side channel attacks
|
||||
*
|
||||
* s := blind^-1 * k^-1 * (blind * m + blind * r * priv_key) mod q
|
||||
*/
|
||||
|
||||
/* Generate a blinding value */
|
||||
do {
|
||||
if (!BN_priv_rand(blind, BN_num_bits(dsa->q) - 1,
|
||||
BN_RAND_TOP_ANY, BN_RAND_BOTTOM_ANY))
|
||||
goto err;
|
||||
} while (BN_is_zero(blind));
|
||||
BN_set_flags(blind, BN_FLG_CONSTTIME);
|
||||
BN_set_flags(blindm, BN_FLG_CONSTTIME);
|
||||
BN_set_flags(tmp, BN_FLG_CONSTTIME);
|
||||
|
||||
/* tmp := blind * priv_key * r mod q */
|
||||
if (!BN_mod_mul(tmp, blind, dsa->priv_key, dsa->q, ctx))
|
||||
goto err;
|
||||
if (!BN_mod_mul(tmp, tmp, ret->r, dsa->q, ctx))
|
||||
goto err;
|
||||
|
||||
/* blindm := blind * m mod q */
|
||||
if (!BN_mod_mul(blindm, blind, m, dsa->q, ctx))
|
||||
goto err;
|
||||
|
||||
/* s : = (blind * priv_key * r) + (blind * m) mod q */
|
||||
if (!BN_mod_add_quick(ret->s, tmp, blindm, dsa->q))
|
||||
goto err;
|
||||
|
||||
/* s := s * k^-1 mod q */
|
||||
if (!BN_mod_mul(ret->s, ret->s, kinv, dsa->q, ctx))
|
||||
goto err;
|
||||
|
||||
/* s:= s * blind^-1 mod q */
|
||||
if (BN_mod_inverse(blind, blind, dsa->q, ctx) == NULL)
|
||||
goto err;
|
||||
if (!BN_mod_mul(ret->s, ret->s, blind, dsa->q, ctx))
|
||||
goto err;
|
||||
|
||||
/*
|
||||
* Redo if r or s is zero as required by FIPS 186-3: this is very
|
||||
* unlikely.
|
||||
@@ -128,8 +162,6 @@ static DSA_SIG *dsa_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
|
||||
ret = NULL;
|
||||
}
|
||||
BN_CTX_free(ctx);
|
||||
BN_clear_free(m);
|
||||
BN_clear_free(xr);
|
||||
BN_clear_free(kinv);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -16,7 +16,9 @@ DSA_SIG *DSA_do_sign(const unsigned char *dgst, int dlen, DSA *dsa)
|
||||
return dsa->meth->dsa_do_sign(dgst, dlen, dsa);
|
||||
}
|
||||
|
||||
#if OPENSSL_API_COMPAT < 0x10200000L
|
||||
int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp)
|
||||
{
|
||||
return dsa->meth->dsa_sign_setup(dsa, ctx_in, kinvp, rp);
|
||||
}
|
||||
#endif
|
||||
@@ -1,5 +1,5 @@
|
||||
#! /usr/bin/env perl
|
||||
# Copyright 2014-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright 2014-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright (c) 2014, Intel Corporation. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the OpenSSL license (the "License"). You may not use
|
||||
@@ -47,7 +47,7 @@ if (!$addx && $win64 && ($flavour =~ /masm/ || $ENV{ASM} =~ /ml64/) &&
|
||||
$addx = ($1>=12);
|
||||
}
|
||||
|
||||
if (!$addx && `$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9])\.([0-9]+)/) {
|
||||
if (!$addx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|based on LLVM) ([3-9])\.([0-9]+)/) {
|
||||
my $ver = $2 + $3/100.0; # 3.1->3.01, 3.10->3.10
|
||||
$avx = ($ver>=3.0) + ($ver>=3.01);
|
||||
$addx = ($ver>=3.03);
|
||||
|
||||
@@ -64,7 +64,9 @@ const EC_METHOD *EC_GF2m_simple_method(void)
|
||||
ec_key_simple_generate_public_key,
|
||||
0, /* keycopy */
|
||||
0, /* keyfinish */
|
||||
ecdh_simple_compute_key
|
||||
ecdh_simple_compute_key,
|
||||
0, /* field_inverse_mod_ord */
|
||||
0 /* blind_coordinates */
|
||||
};
|
||||
|
||||
return &ret;
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2006-2018 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
|
||||
@@ -602,6 +602,14 @@ const EVP_PKEY_ASN1_METHOD eckey_asn1_meth = {
|
||||
ec_pkey_param_check
|
||||
};
|
||||
|
||||
#if !defined(OPENSSL_NO_SM2)
|
||||
const EVP_PKEY_ASN1_METHOD sm2_asn1_meth = {
|
||||
EVP_PKEY_SM2,
|
||||
EVP_PKEY_EC,
|
||||
ASN1_PKEY_ALIAS
|
||||
};
|
||||
#endif
|
||||
|
||||
int EC_KEY_print(BIO *bp, const EC_KEY *x, int off)
|
||||
{
|
||||
int private = EC_KEY_get0_private_key(x) != NULL;
|
||||
|
||||
@@ -116,6 +116,8 @@ static const ERR_STRING_DATA EC_str_functs[] = {
|
||||
"ec_GFp_nist_field_sqr"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_EC_GFP_NIST_GROUP_SET_CURVE, 0),
|
||||
"ec_GFp_nist_group_set_curve"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES, 0),
|
||||
"ec_GFp_simple_blind_coordinates"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT, 0),
|
||||
"ec_GFp_simple_group_check_discriminant"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE, 0),
|
||||
@@ -259,6 +261,12 @@ static const ERR_STRING_DATA EC_str_functs[] = {
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_EC_KEYGEN, 0), "pkey_ec_keygen"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_EC_PARAMGEN, 0), "pkey_ec_paramgen"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_EC_SIGN, 0), "pkey_ec_sign"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_SM2_CTRL, 0), "pkey_sm2_ctrl"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_SM2_CTRL_STR, 0), "pkey_sm2_ctrl_str"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_SM2_INIT, 0), "pkey_sm2_init"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_SM2_KEYGEN, 0), "pkey_sm2_keygen"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_SM2_PARAMGEN, 0), "pkey_sm2_paramgen"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_PKEY_SM2_SIGN, 0), "pkey_sm2_sign"},
|
||||
{ERR_PACK(ERR_LIB_EC, EC_F_VALIDATE_ECX_DERIVE, 0), "validate_ecx_derive"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
@@ -176,6 +176,7 @@ struct ec_method_st {
|
||||
/* Inverse modulo order */
|
||||
int (*field_inverse_mod_ord)(const EC_GROUP *, BIGNUM *r, BIGNUM *x,
|
||||
BN_CTX *ctx);
|
||||
int (*blind_coordinates)(const EC_GROUP *group, EC_POINT *p, BN_CTX *ctx);
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -382,6 +383,8 @@ int ec_GFp_simple_field_mul(const EC_GROUP *, BIGNUM *r, const BIGNUM *a,
|
||||
const BIGNUM *b, BN_CTX *);
|
||||
int ec_GFp_simple_field_sqr(const EC_GROUP *, BIGNUM *r, const BIGNUM *a,
|
||||
BN_CTX *);
|
||||
int ec_GFp_simple_blind_coordinates(const EC_GROUP *group, EC_POINT *p,
|
||||
BN_CTX *ctx);
|
||||
|
||||
/* method functions in ecp_mont.c */
|
||||
int ec_GFp_mont_group_init(EC_GROUP *);
|
||||
@@ -635,3 +638,5 @@ void X25519_public_from_private(uint8_t out_public_value[32],
|
||||
|
||||
int EC_GROUP_do_inverse_ord(const EC_GROUP *group, BIGNUM *res,
|
||||
BIGNUM *x, BN_CTX *ctx);
|
||||
|
||||
int ec_point_blind_coordinates(const EC_GROUP *group, EC_POINT *p, BN_CTX *ctx);
|
||||
@@ -1025,3 +1025,21 @@ int EC_GROUP_do_inverse_ord(const EC_GROUP *group, BIGNUM *res,
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*-
|
||||
* Coordinate blinding for EC_POINT.
|
||||
*
|
||||
* The underlying EC_METHOD can optionally implement this function:
|
||||
* underlying implementations should return 0 on errors, or 1 on
|
||||
* success.
|
||||
*
|
||||
* This wrapper returns 1 in case the underlying EC_METHOD does not
|
||||
* support coordinate blinding.
|
||||
*/
|
||||
int ec_point_blind_coordinates(const EC_GROUP *group, EC_POINT *p, BN_CTX *ctx)
|
||||
{
|
||||
if (group->meth->blind_coordinates == NULL)
|
||||
return 1; /* ignore if not implemented */
|
||||
|
||||
return group->meth->blind_coordinates(group, p, ctx);
|
||||
}
|
||||
+26
-14
@@ -132,10 +132,11 @@ static int ec_mul_consttime(const EC_GROUP *group, EC_POINT *r,
|
||||
const BIGNUM *scalar, const EC_POINT *point,
|
||||
BN_CTX *ctx)
|
||||
{
|
||||
int i, order_bits, group_top, kbit, pbit, Z_is_one;
|
||||
int i, cardinality_bits, group_top, kbit, pbit, Z_is_one;
|
||||
EC_POINT *s = NULL;
|
||||
BIGNUM *k = NULL;
|
||||
BIGNUM *lambda = NULL;
|
||||
BIGNUM *cardinality = NULL;
|
||||
BN_CTX *new_ctx = NULL;
|
||||
int ret = 0;
|
||||
|
||||
@@ -144,8 +145,6 @@ static int ec_mul_consttime(const EC_GROUP *group, EC_POINT *r,
|
||||
|
||||
BN_CTX_start(ctx);
|
||||
|
||||
order_bits = BN_num_bits(group->order);
|
||||
|
||||
s = EC_POINT_new(group);
|
||||
if (s == NULL)
|
||||
goto err;
|
||||
@@ -160,18 +159,20 @@ static int ec_mul_consttime(const EC_GROUP *group, EC_POINT *r,
|
||||
|
||||
EC_POINT_BN_set_flags(s, BN_FLG_CONSTTIME);
|
||||
|
||||
cardinality = BN_CTX_get(ctx);
|
||||
lambda = BN_CTX_get(ctx);
|
||||
k = BN_CTX_get(ctx);
|
||||
if (k == NULL)
|
||||
if (k == NULL || !BN_mul(cardinality, group->order, group->cofactor, ctx))
|
||||
goto err;
|
||||
|
||||
/*
|
||||
* Group orders are often on a word boundary.
|
||||
* Group cardinalities are often on a word boundary.
|
||||
* So when we pad the scalar, some timing diff might
|
||||
* pop if it needs to be expanded due to carries.
|
||||
* So expand ahead of time.
|
||||
*/
|
||||
group_top = bn_get_top(group->order);
|
||||
cardinality_bits = BN_num_bits(cardinality);
|
||||
group_top = bn_get_top(cardinality);
|
||||
if ((bn_wexpand(k, group_top + 1) == NULL)
|
||||
|| (bn_wexpand(lambda, group_top + 1) == NULL))
|
||||
goto err;
|
||||
@@ -181,25 +182,25 @@ static int ec_mul_consttime(const EC_GROUP *group, EC_POINT *r,
|
||||
|
||||
BN_set_flags(k, BN_FLG_CONSTTIME);
|
||||
|
||||
if ((BN_num_bits(k) > order_bits) || (BN_is_negative(k))) {
|
||||
if ((BN_num_bits(k) > cardinality_bits) || (BN_is_negative(k))) {
|
||||
/*-
|
||||
* this is an unusual input, and we don't guarantee
|
||||
* constant-timeness
|
||||
*/
|
||||
if (!BN_nnmod(k, k, group->order, ctx))
|
||||
if (!BN_nnmod(k, k, cardinality, ctx))
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (!BN_add(lambda, k, group->order))
|
||||
if (!BN_add(lambda, k, cardinality))
|
||||
goto err;
|
||||
BN_set_flags(lambda, BN_FLG_CONSTTIME);
|
||||
if (!BN_add(k, lambda, group->order))
|
||||
if (!BN_add(k, lambda, cardinality))
|
||||
goto err;
|
||||
/*
|
||||
* lambda := scalar + order
|
||||
* k := scalar + 2*order
|
||||
* lambda := scalar + cardinality
|
||||
* k := scalar + 2*cardinality
|
||||
*/
|
||||
kbit = BN_is_bit_set(lambda, order_bits);
|
||||
kbit = BN_is_bit_set(lambda, cardinality_bits);
|
||||
BN_consttime_swap(kbit, k, lambda, group_top + 1);
|
||||
|
||||
group_top = bn_get_top(group->field);
|
||||
@@ -211,6 +212,17 @@ static int ec_mul_consttime(const EC_GROUP *group, EC_POINT *r,
|
||||
|| (bn_wexpand(r->Z, group_top) == NULL))
|
||||
goto err;
|
||||
|
||||
/*-
|
||||
* Apply coordinate blinding for EC_POINT.
|
||||
*
|
||||
* The underlying EC_METHOD can optionally implement this function:
|
||||
* ec_point_blind_coordinates() returns 0 in case of errors or 1 on
|
||||
* success or if coordinate blinding is not implemented for this
|
||||
* group.
|
||||
*/
|
||||
if (!ec_point_blind_coordinates(group, s, ctx))
|
||||
goto err;
|
||||
|
||||
/* top bit is a 1, in a fixed pos */
|
||||
if (!EC_POINT_copy(r, s))
|
||||
goto err;
|
||||
@@ -289,7 +301,7 @@ static int ec_mul_consttime(const EC_GROUP *group, EC_POINT *r,
|
||||
* This is XOR. pbit tracks the previous bit of k.
|
||||
*/
|
||||
|
||||
for (i = order_bits - 1; i >= 0; i--) {
|
||||
for (i = cardinality_bits - 1; i >= 0; i--) {
|
||||
kbit = BN_is_bit_set(k, i) ^ pbit;
|
||||
EC_POINT_CSWAP(kbit, r, s, group_top, Z_is_one);
|
||||
if (!EC_POINT_add(group, s, r, s, ctx))
|
||||
|
||||
+5
-108
@@ -16,10 +16,6 @@
|
||||
#include <openssl/evp.h>
|
||||
#include "internal/evp_int.h"
|
||||
|
||||
#if !defined(OPENSSL_NO_SM2)
|
||||
# include "internal/sm2.h"
|
||||
#endif
|
||||
|
||||
/* EC pkey context structure */
|
||||
|
||||
typedef struct {
|
||||
@@ -107,7 +103,6 @@ static int pkey_ec_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
|
||||
unsigned int sltmp;
|
||||
EC_PKEY_CTX *dctx = ctx->data;
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
const int ec_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
|
||||
|
||||
if (!sig) {
|
||||
*siglen = ECDSA_size(ec);
|
||||
@@ -122,15 +117,7 @@ static int pkey_ec_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
|
||||
else
|
||||
type = NID_sha1;
|
||||
|
||||
if (ec_nid == NID_sm2) {
|
||||
#if defined(OPENSSL_NO_SM2)
|
||||
return -1;
|
||||
#else
|
||||
ret = sm2_sign(type, tbs, tbslen, sig, &sltmp, ec);
|
||||
#endif
|
||||
} else {
|
||||
ret = ECDSA_sign(type, tbs, tbslen, sig, &sltmp, ec);
|
||||
}
|
||||
ret = ECDSA_sign(type, tbs, tbslen, sig, &sltmp, ec);
|
||||
|
||||
if (ret <= 0)
|
||||
return ret;
|
||||
@@ -145,22 +132,13 @@ static int pkey_ec_verify(EVP_PKEY_CTX *ctx,
|
||||
int ret, type;
|
||||
EC_PKEY_CTX *dctx = ctx->data;
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
const int ec_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
|
||||
|
||||
if (dctx->md)
|
||||
type = EVP_MD_type(dctx->md);
|
||||
else
|
||||
type = NID_sha1;
|
||||
|
||||
if (ec_nid == NID_sm2) {
|
||||
#if defined(OPENSSL_NO_SM2)
|
||||
ret = -1;
|
||||
#else
|
||||
ret = sm2_verify(type, tbs, tbslen, sig, siglen, ec);
|
||||
#endif
|
||||
} else {
|
||||
ret = ECDSA_verify(type, tbs, tbslen, sig, siglen, ec);
|
||||
}
|
||||
ret = ECDSA_verify(type, tbs, tbslen, sig, siglen, ec);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -202,86 +180,6 @@ static int pkey_ec_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int pkey_ecies_encrypt(EVP_PKEY_CTX *ctx,
|
||||
unsigned char *out, size_t *outlen,
|
||||
const unsigned char *in, size_t inlen)
|
||||
{
|
||||
int ret;
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
const int ec_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
|
||||
|
||||
if (ec_nid == NID_sm2) {
|
||||
# if defined(OPENSSL_NO_SM2)
|
||||
ret = -1;
|
||||
# else
|
||||
int md_type;
|
||||
EC_PKEY_CTX *dctx = ctx->data;
|
||||
|
||||
if (dctx->md)
|
||||
md_type = EVP_MD_type(dctx->md);
|
||||
else
|
||||
md_type = NID_sm3;
|
||||
|
||||
if (out == NULL) {
|
||||
if (!sm2_ciphertext_size(ec, EVP_get_digestbynid(md_type), inlen,
|
||||
outlen))
|
||||
ret = -1;
|
||||
else
|
||||
ret = 1;
|
||||
}
|
||||
else {
|
||||
ret = sm2_encrypt(ec, EVP_get_digestbynid(md_type),
|
||||
in, inlen, out, outlen);
|
||||
}
|
||||
# endif
|
||||
} else {
|
||||
/* standard ECIES not implemented */
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int pkey_ecies_decrypt(EVP_PKEY_CTX *ctx,
|
||||
unsigned char *out, size_t *outlen,
|
||||
const unsigned char *in, size_t inlen)
|
||||
{
|
||||
int ret;
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
const int ec_nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
|
||||
|
||||
if (ec_nid == NID_sm2) {
|
||||
# if defined(OPENSSL_NO_SM2)
|
||||
ret = -1;
|
||||
# else
|
||||
int md_type;
|
||||
EC_PKEY_CTX *dctx = ctx->data;
|
||||
|
||||
if (dctx->md)
|
||||
md_type = EVP_MD_type(dctx->md);
|
||||
else
|
||||
md_type = NID_sm3;
|
||||
|
||||
if (out == NULL) {
|
||||
if (!sm2_plaintext_size(ec, EVP_get_digestbynid(md_type), inlen,
|
||||
outlen))
|
||||
ret = -1;
|
||||
else
|
||||
ret = 1;
|
||||
}
|
||||
else {
|
||||
ret = sm2_decrypt(ec, EVP_get_digestbynid(md_type),
|
||||
in, inlen, out, outlen);
|
||||
}
|
||||
# endif
|
||||
} else {
|
||||
/* standard ECIES not implemented */
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int pkey_ec_kdf_derive(EVP_PKEY_CTX *ctx,
|
||||
unsigned char *key, size_t *keylen)
|
||||
{
|
||||
@@ -420,8 +318,7 @@ static int pkey_ec_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
|
||||
EVP_MD_type((const EVP_MD *)p2) != NID_sha224 &&
|
||||
EVP_MD_type((const EVP_MD *)p2) != NID_sha256 &&
|
||||
EVP_MD_type((const EVP_MD *)p2) != NID_sha384 &&
|
||||
EVP_MD_type((const EVP_MD *)p2) != NID_sha512 &&
|
||||
EVP_MD_type((const EVP_MD *)p2) != NID_sm3) {
|
||||
EVP_MD_type((const EVP_MD *)p2) != NID_sha512) {
|
||||
ECerr(EC_F_PKEY_EC_CTRL, EC_R_INVALID_DIGEST_TYPE);
|
||||
return 0;
|
||||
}
|
||||
@@ -552,10 +449,10 @@ const EVP_PKEY_METHOD ec_pkey_meth = {
|
||||
0, 0, 0, 0,
|
||||
|
||||
0,
|
||||
pkey_ecies_encrypt,
|
||||
0,
|
||||
|
||||
0,
|
||||
pkey_ecies_decrypt,
|
||||
0,
|
||||
|
||||
0,
|
||||
#ifndef OPENSSL_NO_EC
|
||||
|
||||
@@ -288,7 +288,7 @@ ECDSA_SIG *ossl_ecdsa_sign_sig(const unsigned char *dgst, int dgst_len,
|
||||
*
|
||||
* We will blind this to protect against side channel attacks
|
||||
*
|
||||
* s := k^-1 * blind^-1 * (blind * m + blind * r * priv_key) mod order
|
||||
* s := blind^-1 * k^-1 * (blind * m + blind * r * priv_key) mod order
|
||||
*/
|
||||
|
||||
/* Generate a blinding value */
|
||||
@@ -323,6 +323,12 @@ ECDSA_SIG *ossl_ecdsa_sign_sig(const unsigned char *dgst, int dgst_len,
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* s := s * k^-1 mod order */
|
||||
if (!BN_mod_mul(s, s, ckinv, order, ctx)) {
|
||||
ECerr(EC_F_OSSL_ECDSA_SIGN_SIG, ERR_R_BN_LIB);
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* s:= s * blind^-1 mod order */
|
||||
if (BN_mod_inverse(blind, blind, order, ctx) == NULL) {
|
||||
ECerr(EC_F_OSSL_ECDSA_SIGN_SIG, ERR_R_BN_LIB);
|
||||
@@ -333,12 +339,6 @@ ECDSA_SIG *ossl_ecdsa_sign_sig(const unsigned char *dgst, int dgst_len,
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* s := s * k^-1 mod order */
|
||||
if (!BN_mod_mul(s, s, ckinv, order, ctx)) {
|
||||
ECerr(EC_F_OSSL_ECDSA_SIGN_SIG, ERR_R_BN_LIB);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (BN_is_zero(s)) {
|
||||
/*
|
||||
* if kinv and r have been supplied by the caller, don't
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2001-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
@@ -61,7 +61,9 @@ const EC_METHOD *EC_GFp_mont_method(void)
|
||||
ec_key_simple_generate_public_key,
|
||||
0, /* keycopy */
|
||||
0, /* keyfinish */
|
||||
ecdh_simple_compute_key
|
||||
ecdh_simple_compute_key,
|
||||
0, /* field_inverse_mod_ord */
|
||||
ec_GFp_simple_blind_coordinates
|
||||
};
|
||||
|
||||
return &ret;
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2001-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2001-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
|
||||
*
|
||||
* Licensed under the OpenSSL license (the "License"). You may not use
|
||||
@@ -63,7 +63,9 @@ const EC_METHOD *EC_GFp_nist_method(void)
|
||||
ec_key_simple_generate_public_key,
|
||||
0, /* keycopy */
|
||||
0, /* keyfinish */
|
||||
ecdh_simple_compute_key
|
||||
ecdh_simple_compute_key,
|
||||
0, /* field_inverse_mod_ord */
|
||||
ec_GFp_simple_blind_coordinates
|
||||
};
|
||||
|
||||
return &ret;
|
||||
|
||||
@@ -290,7 +290,9 @@ const EC_METHOD *EC_GFp_nistp224_method(void)
|
||||
ec_key_simple_generate_public_key,
|
||||
0, /* keycopy */
|
||||
0, /* keyfinish */
|
||||
ecdh_simple_compute_key
|
||||
ecdh_simple_compute_key,
|
||||
0, /* field_inverse_mod_ord */
|
||||
0 /* blind_coordinates */
|
||||
};
|
||||
|
||||
return &ret;
|
||||
|
||||
@@ -1658,7 +1658,9 @@ const EC_METHOD *EC_GFp_nistp521_method(void)
|
||||
ec_key_simple_generate_public_key,
|
||||
0, /* keycopy */
|
||||
0, /* keyfinish */
|
||||
ecdh_simple_compute_key
|
||||
ecdh_simple_compute_key,
|
||||
0, /* field_inverse_mod_ord */
|
||||
0 /* blind_coordinates */
|
||||
};
|
||||
|
||||
return &ret;
|
||||
|
||||
@@ -1730,7 +1730,8 @@ const EC_METHOD *EC_GFp_nistz256_method(void)
|
||||
0, /* keycopy */
|
||||
0, /* keyfinish */
|
||||
ecdh_simple_compute_key,
|
||||
ecp_nistz256_inv_mod_ord /* can be #define-d NULL */
|
||||
ecp_nistz256_inv_mod_ord, /* can be #define-d NULL */
|
||||
0 /* blind_coordinates */
|
||||
};
|
||||
|
||||
return &ret;
|
||||
|
||||
+57
-1
@@ -62,7 +62,9 @@ const EC_METHOD *EC_GFp_simple_method(void)
|
||||
ec_key_simple_generate_public_key,
|
||||
0, /* keycopy */
|
||||
0, /* keyfinish */
|
||||
ecdh_simple_compute_key
|
||||
ecdh_simple_compute_key,
|
||||
0, /* field_inverse_mod_ord */
|
||||
ec_GFp_simple_blind_coordinates
|
||||
};
|
||||
|
||||
return &ret;
|
||||
@@ -1363,3 +1365,57 @@ int ec_GFp_simple_field_sqr(const EC_GROUP *group, BIGNUM *r, const BIGNUM *a,
|
||||
{
|
||||
return BN_mod_sqr(r, a, group->field, ctx);
|
||||
}
|
||||
|
||||
/*-
|
||||
* Apply randomization of EC point projective coordinates:
|
||||
*
|
||||
* (X, Y ,Z ) = (lambda^2*X, lambda^3*Y, lambda*Z)
|
||||
* lambda = [1,group->field)
|
||||
*
|
||||
*/
|
||||
int ec_GFp_simple_blind_coordinates(const EC_GROUP *group, EC_POINT *p,
|
||||
BN_CTX *ctx)
|
||||
{
|
||||
int ret = 0;
|
||||
BIGNUM *lambda = NULL;
|
||||
BIGNUM *temp = NULL;
|
||||
|
||||
BN_CTX_start(ctx);
|
||||
lambda = BN_CTX_get(ctx);
|
||||
temp = BN_CTX_get(ctx);
|
||||
if (temp == NULL) {
|
||||
ECerr(EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES, ERR_R_MALLOC_FAILURE);
|
||||
goto err;
|
||||
}
|
||||
|
||||
/* make sure lambda is not zero */
|
||||
do {
|
||||
if (!BN_priv_rand_range(lambda, group->field)) {
|
||||
ECerr(EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES, ERR_R_BN_LIB);
|
||||
goto err;
|
||||
}
|
||||
} while (BN_is_zero(lambda));
|
||||
|
||||
/* if field_encode defined convert between representations */
|
||||
if (group->meth->field_encode != NULL
|
||||
&& !group->meth->field_encode(group, lambda, lambda, ctx))
|
||||
goto err;
|
||||
if (!group->meth->field_mul(group, p->Z, p->Z, lambda, ctx))
|
||||
goto err;
|
||||
if (!group->meth->field_sqr(group, temp, lambda, ctx))
|
||||
goto err;
|
||||
if (!group->meth->field_mul(group, p->X, p->X, temp, ctx))
|
||||
goto err;
|
||||
if (!group->meth->field_mul(group, temp, temp, lambda, ctx))
|
||||
goto err;
|
||||
if (!group->meth->field_mul(group, p->Y, p->Y, temp, ctx))
|
||||
goto err;
|
||||
p->Z_is_one = 0;
|
||||
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
BN_CTX_end(ctx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2001-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2001-2018 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
|
||||
@@ -18,7 +18,7 @@ void ENGINE_load_builtin_engines(void)
|
||||
OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_ALL_BUILTIN, NULL);
|
||||
}
|
||||
|
||||
#if (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)) && !defined(OPENSSL_NO_DEPRECATED)
|
||||
#if (defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)) && OPENSSL_API_COMPAT < 0x10100000L
|
||||
void ENGINE_setup_bsd_cryptodev(void)
|
||||
{
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2006-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2006-2018 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
|
||||
|
||||
@@ -550,6 +550,7 @@ EC_F_EC_GFP_NISTP521_POINT_GET_AFFINE_COORDINATES:235:\
|
||||
EC_F_EC_GFP_NIST_FIELD_MUL:200:ec_GFp_nist_field_mul
|
||||
EC_F_EC_GFP_NIST_FIELD_SQR:201:ec_GFp_nist_field_sqr
|
||||
EC_F_EC_GFP_NIST_GROUP_SET_CURVE:202:ec_GFp_nist_group_set_curve
|
||||
EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES:287:ec_GFp_simple_blind_coordinates
|
||||
EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT:165:\
|
||||
ec_GFp_simple_group_check_discriminant
|
||||
EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE:166:ec_GFp_simple_group_set_curve
|
||||
@@ -716,9 +717,11 @@ EVP_F_DES_EDE3_WRAP_CIPHER:171:des_ede3_wrap_cipher
|
||||
EVP_F_DO_SIGVER_INIT:161:do_sigver_init
|
||||
EVP_F_ENC_NEW:199:enc_new
|
||||
EVP_F_EVP_CIPHERINIT_EX:123:EVP_CipherInit_ex
|
||||
EVP_F_EVP_CIPHER_ASN1_TO_PARAM:204:EVP_CIPHER_asn1_to_param
|
||||
EVP_F_EVP_CIPHER_CTX_COPY:163:EVP_CIPHER_CTX_copy
|
||||
EVP_F_EVP_CIPHER_CTX_CTRL:124:EVP_CIPHER_CTX_ctrl
|
||||
EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH:122:EVP_CIPHER_CTX_set_key_length
|
||||
EVP_F_EVP_CIPHER_PARAM_TO_ASN1:205:EVP_CIPHER_param_to_asn1
|
||||
EVP_F_EVP_DECRYPTFINAL_EX:101:EVP_DecryptFinal_ex
|
||||
EVP_F_EVP_DECRYPTUPDATE:166:EVP_DecryptUpdate
|
||||
EVP_F_EVP_DIGESTFINALXOF:174:EVP_DigestFinalXOF
|
||||
@@ -772,6 +775,7 @@ EVP_F_EVP_PKEY_PARAMGEN_INIT:149:EVP_PKEY_paramgen_init
|
||||
EVP_F_EVP_PKEY_PARAM_CHECK:189:EVP_PKEY_param_check
|
||||
EVP_F_EVP_PKEY_PUBLIC_CHECK:190:EVP_PKEY_public_check
|
||||
EVP_F_EVP_PKEY_SET1_ENGINE:187:EVP_PKEY_set1_engine
|
||||
EVP_F_EVP_PKEY_SET_ALIAS_TYPE:206:EVP_PKEY_set_alias_type
|
||||
EVP_F_EVP_PKEY_SIGN:140:EVP_PKEY_sign
|
||||
EVP_F_EVP_PKEY_SIGN_INIT:141:EVP_PKEY_sign_init
|
||||
EVP_F_EVP_PKEY_VERIFY:142:EVP_PKEY_verify
|
||||
@@ -1065,6 +1069,10 @@ RSA_F_RSA_VERIFY:119:RSA_verify
|
||||
RSA_F_RSA_VERIFY_ASN1_OCTET_STRING:120:RSA_verify_ASN1_OCTET_STRING
|
||||
RSA_F_RSA_VERIFY_PKCS1_PSS_MGF1:126:RSA_verify_PKCS1_PSS_mgf1
|
||||
RSA_F_SETUP_TBUF:167:setup_tbuf
|
||||
SM2_F_PKEY_SM2_CTRL:109:pkey_sm2_ctrl
|
||||
SM2_F_PKEY_SM2_CTRL_STR:110:pkey_sm2_ctrl_str
|
||||
SM2_F_PKEY_SM2_INIT:111:pkey_sm2_init
|
||||
SM2_F_PKEY_SM2_SIGN:112:pkey_sm2_sign
|
||||
SM2_F_SM2_COMPUTE_MSG_HASH:100:sm2_compute_msg_hash
|
||||
SM2_F_SM2_COMPUTE_USERID_DIGEST:101:sm2_compute_userid_digest
|
||||
SM2_F_SM2_DECRYPT:102:sm2_decrypt
|
||||
@@ -1831,6 +1839,7 @@ ASN1_R_UNKNOWN_PUBLIC_KEY_TYPE:163:unknown public key type
|
||||
ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM:199:unknown signature algorithm
|
||||
ASN1_R_UNKNOWN_TAG:194:unknown tag
|
||||
ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE:164:unsupported any defined by type
|
||||
ASN1_R_UNSUPPORTED_CIPHER:228:unsupported cipher
|
||||
ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE:167:unsupported public key type
|
||||
ASN1_R_UNSUPPORTED_TYPE:196:unsupported type
|
||||
ASN1_R_WRONG_INTEGER_TYPE:225:wrong integer type
|
||||
@@ -2524,10 +2533,13 @@ RSA_R_VALUE_MISSING:147:value missing
|
||||
RSA_R_WRONG_SIGNATURE_LENGTH:119:wrong signature length
|
||||
SM2_R_ASN1_ERROR:100:asn1 error
|
||||
SM2_R_BAD_SIGNATURE:101:bad signature
|
||||
SM2_R_BUFFER_TOO_SMALL:107:buffer too small
|
||||
SM2_R_INVALID_CURVE:108:invalid curve
|
||||
SM2_R_INVALID_DIGEST:102:invalid digest
|
||||
SM2_R_INVALID_DIGEST_TYPE:103:invalid digest type
|
||||
SM2_R_INVALID_ENCODING:104:invalid encoding
|
||||
SM2_R_INVALID_FIELD:105:invalid field
|
||||
SM2_R_NO_PARAMETERS_SET:109:no parameters set
|
||||
SM2_R_USER_ID_TOO_LARGE:106:user id too large
|
||||
SSL_R_APP_DATA_IN_HANDSHAKE:100:app data in handshake
|
||||
SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT:272:\
|
||||
|
||||
@@ -35,12 +35,16 @@ static const ERR_STRING_DATA EVP_str_functs[] = {
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_DO_SIGVER_INIT, 0), "do_sigver_init"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_ENC_NEW, 0), "enc_new"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_CIPHERINIT_EX, 0), "EVP_CipherInit_ex"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_CIPHER_ASN1_TO_PARAM, 0),
|
||||
"EVP_CIPHER_asn1_to_param"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_CIPHER_CTX_COPY, 0),
|
||||
"EVP_CIPHER_CTX_copy"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_CIPHER_CTX_CTRL, 0),
|
||||
"EVP_CIPHER_CTX_ctrl"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH, 0),
|
||||
"EVP_CIPHER_CTX_set_key_length"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_CIPHER_PARAM_TO_ASN1, 0),
|
||||
"EVP_CIPHER_param_to_asn1"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_DECRYPTFINAL_EX, 0),
|
||||
"EVP_DecryptFinal_ex"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_DECRYPTUPDATE, 0), "EVP_DecryptUpdate"},
|
||||
@@ -118,6 +122,8 @@ static const ERR_STRING_DATA EVP_str_functs[] = {
|
||||
"EVP_PKEY_public_check"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_PKEY_SET1_ENGINE, 0),
|
||||
"EVP_PKEY_set1_engine"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_PKEY_SET_ALIAS_TYPE, 0),
|
||||
"EVP_PKEY_set_alias_type"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_PKEY_SIGN, 0), "EVP_PKEY_sign"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_PKEY_SIGN_INIT, 0), "EVP_PKEY_sign_init"},
|
||||
{ERR_PACK(ERR_LIB_EVP, EVP_F_EVP_PKEY_VERIFY, 0), "EVP_PKEY_verify"},
|
||||
|
||||
+15
-3
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 1995-2018 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
|
||||
@@ -32,7 +32,7 @@ int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
||||
case EVP_CIPH_CCM_MODE:
|
||||
case EVP_CIPH_XTS_MODE:
|
||||
case EVP_CIPH_OCB_MODE:
|
||||
ret = -1;
|
||||
ret = -2;
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -40,6 +40,12 @@ int EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
||||
}
|
||||
} else
|
||||
ret = -1;
|
||||
if (ret <= 0)
|
||||
EVPerr(EVP_F_EVP_CIPHER_PARAM_TO_ASN1, ret == -2 ?
|
||||
ASN1_R_UNSUPPORTED_CIPHER :
|
||||
EVP_R_CIPHER_PARAMETER_ERROR);
|
||||
if (ret < -1)
|
||||
ret = -1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -60,7 +66,7 @@ int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
||||
case EVP_CIPH_CCM_MODE:
|
||||
case EVP_CIPH_XTS_MODE:
|
||||
case EVP_CIPH_OCB_MODE:
|
||||
ret = -1;
|
||||
ret = -2;
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -69,6 +75,12 @@ int EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
|
||||
}
|
||||
} else
|
||||
ret = -1;
|
||||
if (ret <= 0)
|
||||
EVPerr(EVP_F_EVP_CIPHER_ASN1_TO_PARAM, ret == -2 ?
|
||||
EVP_R_UNSUPPORTED_CIPHER :
|
||||
EVP_R_CIPHER_PARAMETER_ERROR);
|
||||
if (ret < -1)
|
||||
ret = -1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@@ -356,6 +356,26 @@ int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len)
|
||||
{
|
||||
return pkey_set_type(pkey, NULL, EVP_PKEY_NONE, str, len);
|
||||
}
|
||||
|
||||
int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type)
|
||||
{
|
||||
if (pkey->type == type) {
|
||||
return 1; /* it already is that type */
|
||||
}
|
||||
|
||||
/*
|
||||
* The application is requesting to alias this to a different pkey type,
|
||||
* but not one that resolves to the base type.
|
||||
*/
|
||||
if (EVP_PKEY_type(type) != EVP_PKEY_base_id(pkey)) {
|
||||
EVPerr(EVP_F_EVP_PKEY_SET_ALIAS_TYPE, EVP_R_UNSUPPORTED_ALGORITHM);
|
||||
return 0;
|
||||
}
|
||||
|
||||
pkey->type = type;
|
||||
return 1;
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_ENGINE
|
||||
int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e)
|
||||
{
|
||||
|
||||
@@ -64,6 +64,9 @@ static const EVP_PKEY_METHOD *standard_methods[] = {
|
||||
&ed25519_pkey_meth,
|
||||
&ed448_pkey_meth,
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_SM2
|
||||
&sm2_pkey_meth,
|
||||
#endif
|
||||
};
|
||||
|
||||
DECLARE_OBJ_BSEARCH_CMP_FN(const EVP_PKEY_METHOD *, const EVP_PKEY_METHOD *,
|
||||
@@ -101,10 +104,9 @@ static EVP_PKEY_CTX *int_ctx_new(EVP_PKEY *pkey, ENGINE *e, int id)
|
||||
{
|
||||
EVP_PKEY_CTX *ret;
|
||||
const EVP_PKEY_METHOD *pmeth;
|
||||
|
||||
if (id == -1) {
|
||||
if (!pkey || !pkey->ameth)
|
||||
return NULL;
|
||||
id = pkey->ameth->pkey_id;
|
||||
id = pkey->type;
|
||||
}
|
||||
#ifndef OPENSSL_NO_ENGINE
|
||||
if (e == NULL && pkey != NULL)
|
||||
|
||||
@@ -76,6 +76,7 @@ extern const EVP_PKEY_ASN1_METHOD ecx25519_asn1_meth;
|
||||
extern const EVP_PKEY_ASN1_METHOD ecx448_asn1_meth;
|
||||
extern const EVP_PKEY_ASN1_METHOD ed25519_asn1_meth;
|
||||
extern const EVP_PKEY_ASN1_METHOD ed448_asn1_meth;
|
||||
extern const EVP_PKEY_ASN1_METHOD sm2_asn1_meth;
|
||||
extern const EVP_PKEY_ASN1_METHOD poly1305_asn1_meth;
|
||||
|
||||
extern const EVP_PKEY_ASN1_METHOD hmac_asn1_meth;
|
||||
|
||||
@@ -90,6 +90,7 @@ extern const EVP_PKEY_METHOD dh_pkey_meth;
|
||||
extern const EVP_PKEY_METHOD dhx_pkey_meth;
|
||||
extern const EVP_PKEY_METHOD dsa_pkey_meth;
|
||||
extern const EVP_PKEY_METHOD ec_pkey_meth;
|
||||
extern const EVP_PKEY_METHOD sm2_pkey_meth;
|
||||
extern const EVP_PKEY_METHOD ecx25519_pkey_meth;
|
||||
extern const EVP_PKEY_METHOD ecx448_pkey_meth;
|
||||
extern const EVP_PKEY_METHOD ed25519_pkey_meth;
|
||||
|
||||
@@ -93,149 +93,31 @@
|
||||
# error "HASH_BLOCK_DATA_ORDER must be defined!"
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Engage compiler specific rotate intrinsic function if available.
|
||||
*/
|
||||
#undef ROTATE
|
||||
#ifndef PEDANTIC
|
||||
# if defined(_MSC_VER)
|
||||
# define ROTATE(a,n) _lrotl(a,n)
|
||||
# elif defined(__ICC)
|
||||
# define ROTATE(a,n) _rotl(a,n)
|
||||
# elif defined(__GNUC__) && __GNUC__>=2 && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
|
||||
/*
|
||||
* Some GNU C inline assembler templates. Note that these are
|
||||
* rotates by *constant* number of bits! But that's exactly
|
||||
* what we need here...
|
||||
*/
|
||||
# if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)
|
||||
# define ROTATE(a,n) ({ register unsigned int ret; \
|
||||
asm ( \
|
||||
"roll %1,%0" \
|
||||
: "=r"(ret) \
|
||||
: "I"(n), "0"((unsigned int)(a)) \
|
||||
: "cc"); \
|
||||
ret; \
|
||||
})
|
||||
# elif defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
|
||||
defined(__powerpc) || defined(__ppc__) || defined(__powerpc64__)
|
||||
# define ROTATE(a,n) ({ register unsigned int ret; \
|
||||
asm ( \
|
||||
"rlwinm %0,%1,%2,0,31" \
|
||||
: "=r"(ret) \
|
||||
: "r"(a), "I"(n)); \
|
||||
ret; \
|
||||
})
|
||||
# elif defined(__s390x__)
|
||||
# define ROTATE(a,n) ({ register unsigned int ret; \
|
||||
asm ("rll %0,%1,%2" \
|
||||
: "=r"(ret) \
|
||||
: "r"(a), "I"(n)); \
|
||||
ret; \
|
||||
})
|
||||
# endif
|
||||
# endif
|
||||
#endif /* PEDANTIC */
|
||||
|
||||
#ifndef ROTATE
|
||||
# define ROTATE(a,n) (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
|
||||
#endif
|
||||
#define ROTATE(a,n) (((a)<<(n))|(((a)&0xffffffff)>>(32-(n))))
|
||||
|
||||
#if defined(DATA_ORDER_IS_BIG_ENDIAN)
|
||||
|
||||
# ifndef PEDANTIC
|
||||
# if defined(__GNUC__) && __GNUC__>=2 && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
|
||||
# if ((defined(__i386) || defined(__i386__)) && !defined(I386_ONLY)) || \
|
||||
(defined(__x86_64) || defined(__x86_64__))
|
||||
# if !defined(B_ENDIAN)
|
||||
/*
|
||||
* This gives ~30-40% performance improvement in SHA-256 compiled
|
||||
* with gcc [on P4]. Well, first macro to be frank. We can pull
|
||||
* this trick on x86* platforms only, because these CPUs can fetch
|
||||
* unaligned data without raising an exception.
|
||||
*/
|
||||
# define HOST_c2l(c,l) ({ unsigned int r=*((const unsigned int *)(c)); \
|
||||
asm ("bswapl %0":"=r"(r):"0"(r)); \
|
||||
(c)+=4; (l)=r; })
|
||||
# define HOST_l2c(l,c) ({ unsigned int r=(l); \
|
||||
asm ("bswapl %0":"=r"(r):"0"(r)); \
|
||||
*((unsigned int *)(c))=r; (c)+=4; r; })
|
||||
# endif
|
||||
# elif defined(__aarch64__)
|
||||
# if defined(__BYTE_ORDER__)
|
||||
# if defined(__ORDER_LITTLE_ENDIAN__) && __BYTE_ORDER__==__ORDER_LITTLE_ENDIAN__
|
||||
# define HOST_c2l(c,l) ({ unsigned int r; \
|
||||
asm ("rev %w0,%w1" \
|
||||
:"=r"(r) \
|
||||
:"r"(*((const unsigned int *)(c))));\
|
||||
(c)+=4; (l)=r; })
|
||||
# define HOST_l2c(l,c) ({ unsigned int r; \
|
||||
asm ("rev %w0,%w1" \
|
||||
:"=r"(r) \
|
||||
:"r"((unsigned int)(l)));\
|
||||
*((unsigned int *)(c))=r; (c)+=4; r; })
|
||||
# elif defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__==__ORDER_BIG_ENDIAN__
|
||||
# define HOST_c2l(c,l) ((l)=*((const unsigned int *)(c)), (c)+=4, (l))
|
||||
# define HOST_l2c(l,c) (*((unsigned int *)(c))=(l), (c)+=4, (l))
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
# if defined(__s390__) || defined(__s390x__)
|
||||
# define HOST_c2l(c,l) ((l)=*((const unsigned int *)(c)), (c)+=4, (l))
|
||||
# define HOST_l2c(l,c) (*((unsigned int *)(c))=(l), (c)+=4, (l))
|
||||
# endif
|
||||
# endif
|
||||
|
||||
# ifndef HOST_c2l
|
||||
# define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++)))<<24), \
|
||||
# define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++)))<<24), \
|
||||
l|=(((unsigned long)(*((c)++)))<<16), \
|
||||
l|=(((unsigned long)(*((c)++)))<< 8), \
|
||||
l|=(((unsigned long)(*((c)++))) ) )
|
||||
# endif
|
||||
# ifndef HOST_l2c
|
||||
# define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
|
||||
# define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l)>>24)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l) )&0xff), \
|
||||
l)
|
||||
# endif
|
||||
|
||||
#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
|
||||
|
||||
# ifndef PEDANTIC
|
||||
# if defined(__GNUC__) && __GNUC__>=2 && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM)
|
||||
# if defined(__s390x__)
|
||||
# define HOST_c2l(c,l) ({ asm ("lrv %0,%1" \
|
||||
:"=d"(l) :"m"(*(const unsigned int *)(c)));\
|
||||
(c)+=4; (l); })
|
||||
# define HOST_l2c(l,c) ({ asm ("strv %1,%0" \
|
||||
:"=m"(*(unsigned int *)(c)) :"d"(l));\
|
||||
(c)+=4; (l); })
|
||||
# endif
|
||||
# endif
|
||||
# if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)
|
||||
# ifndef B_ENDIAN
|
||||
/* See comment in DATA_ORDER_IS_BIG_ENDIAN section. */
|
||||
# define HOST_c2l(c,l) ((l)=*((const unsigned int *)(c)), (c)+=4, l)
|
||||
# define HOST_l2c(l,c) (*((unsigned int *)(c))=(l), (c)+=4, l)
|
||||
# endif
|
||||
# endif
|
||||
# endif
|
||||
|
||||
# ifndef HOST_c2l
|
||||
# define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++))) ), \
|
||||
# define HOST_c2l(c,l) (l =(((unsigned long)(*((c)++))) ), \
|
||||
l|=(((unsigned long)(*((c)++)))<< 8), \
|
||||
l|=(((unsigned long)(*((c)++)))<<16), \
|
||||
l|=(((unsigned long)(*((c)++)))<<24) )
|
||||
# endif
|
||||
# ifndef HOST_l2c
|
||||
# define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
|
||||
# define HOST_l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>> 8)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>>16)&0xff), \
|
||||
*((c)++)=(unsigned char)(((l)>>24)&0xff), \
|
||||
l)
|
||||
# endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -42,15 +42,15 @@ int sm2_do_verify(const EC_KEY *key,
|
||||
const char *user_id, const uint8_t *msg, size_t msg_len);
|
||||
|
||||
/*
|
||||
* SM2 signature generation. Assumes input is an SM3 digest
|
||||
* SM2 signature generation.
|
||||
*/
|
||||
int sm2_sign(int type, const unsigned char *dgst, int dgstlen,
|
||||
int sm2_sign(const unsigned char *dgst, int dgstlen,
|
||||
unsigned char *sig, unsigned int *siglen, EC_KEY *eckey);
|
||||
|
||||
/*
|
||||
* SM2 signature verification. Assumes input is an SM3 digest
|
||||
* SM2 signature verification.
|
||||
*/
|
||||
int sm2_verify(int type, const unsigned char *dgst, int dgstlen,
|
||||
int sm2_verify(const unsigned char *dgst, int dgstlen,
|
||||
const unsigned char *sig, int siglen, EC_KEY *eckey);
|
||||
|
||||
|
||||
|
||||
@@ -23,6 +23,10 @@ int ERR_load_SM2_strings(void);
|
||||
/*
|
||||
* SM2 function codes.
|
||||
*/
|
||||
# define SM2_F_PKEY_SM2_CTRL 109
|
||||
# define SM2_F_PKEY_SM2_CTRL_STR 110
|
||||
# define SM2_F_PKEY_SM2_INIT 111
|
||||
# define SM2_F_PKEY_SM2_SIGN 112
|
||||
# define SM2_F_SM2_COMPUTE_MSG_HASH 100
|
||||
# define SM2_F_SM2_COMPUTE_USERID_DIGEST 101
|
||||
# define SM2_F_SM2_DECRYPT 102
|
||||
@@ -38,10 +42,13 @@ int ERR_load_SM2_strings(void);
|
||||
*/
|
||||
# define SM2_R_ASN1_ERROR 100
|
||||
# define SM2_R_BAD_SIGNATURE 101
|
||||
# define SM2_R_BUFFER_TOO_SMALL 107
|
||||
# define SM2_R_INVALID_CURVE 108
|
||||
# define SM2_R_INVALID_DIGEST 102
|
||||
# define SM2_R_INVALID_DIGEST_TYPE 103
|
||||
# define SM2_R_INVALID_ENCODING 104
|
||||
# define SM2_R_INVALID_FIELD 105
|
||||
# define SM2_R_NO_PARAMETERS_SET 109
|
||||
# define SM2_R_USER_ID_TOO_LARGE 106
|
||||
|
||||
# endif
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2010-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2010-2018 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
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2013-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2013-2018 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
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 1999-2018 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
|
||||
@@ -146,25 +146,17 @@ PKCS12_SAFEBAG *PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid,
|
||||
X509_SIG *p8;
|
||||
|
||||
pbe_ciph = EVP_get_cipherbynid(pbe_nid);
|
||||
|
||||
if (pbe_ciph)
|
||||
pbe_nid = -1;
|
||||
|
||||
p8 = PKCS8_encrypt(pbe_nid, pbe_ciph, pass, passlen, salt, saltlen, iter,
|
||||
p8inf);
|
||||
|
||||
if (p8 == NULL) {
|
||||
PKCS12err(PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT, ERR_R_MALLOC_FAILURE);
|
||||
if (p8 == NULL)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bag = PKCS12_SAFEBAG_create0_pkcs8(p8);
|
||||
|
||||
if (bag == NULL) {
|
||||
PKCS12err(PKCS12_F_PKCS12_SAFEBAG_CREATE_PKCS8_ENCRYPT, ERR_R_MALLOC_FAILURE);
|
||||
if (bag == NULL)
|
||||
X509_SIG_free(p8);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return bag;
|
||||
}
|
||||
@@ -1,5 +1,5 @@
|
||||
#! /usr/bin/env perl
|
||||
# Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright 2016-2018 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
|
||||
@@ -71,7 +71,7 @@ if ($sse2) {
|
||||
$avx = ($1>=2.09) + ($1>=2.10);
|
||||
}
|
||||
|
||||
if (!$avx && `$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9]\.[0-9]+)/) {
|
||||
if (!$avx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|based on LLVM) ([3-9]\.[0-9]+)/) {
|
||||
$avx = ($2>=3.0) + ($2>3.0);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#! /usr/bin/env perl
|
||||
# Copyright 1998-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright 1998-2018 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
|
||||
@@ -144,7 +144,7 @@ $ymm=1 if ($xmm && !$ymm && $ARGV[0] eq "win32" &&
|
||||
`ml 2>&1` =~ /Version ([0-9]+)\./ &&
|
||||
$1>=10); # first version supporting AVX
|
||||
|
||||
$ymm=1 if ($xmm && !$ymm && `$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9]\.[0-9]+)/ &&
|
||||
$ymm=1 if ($xmm && !$ymm && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|based on LLVM) ([3-9]\.[0-9]+)/ &&
|
||||
$2>=3.0); # first version supporting AVX
|
||||
|
||||
$shaext=$xmm; ### set to zero if compiling for 1.0.1
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
#! /usr/bin/env perl
|
||||
# Copyright 2007-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright 2007-2018 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
|
||||
@@ -96,7 +96,7 @@ if ($xmm && !$avx && $ARGV[0] eq "win32" &&
|
||||
$avx = ($1>=10) + ($1>=11);
|
||||
}
|
||||
|
||||
if ($xmm && !$avx && `$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9]\.[0-9]+)/) {
|
||||
if ($xmm && !$avx && `$ENV{CC} -v 2>&1` =~ /((?:^clang|LLVM) version|based on LLVM) ([3-9]\.[0-9]+)/) {
|
||||
$avx = ($2>=3.0) + ($2>3.0);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
LIBS=../../libcrypto
|
||||
SOURCE[../../libcrypto]=\
|
||||
sm2_za.c sm2_sign.c sm2_crypt.c sm2_err.c
|
||||
|
||||
sm2_za.c sm2_sign.c sm2_crypt.c sm2_err.c sm2_pmeth.c
|
||||
|
||||
|
||||
@@ -14,6 +14,10 @@
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
static const ERR_STRING_DATA SM2_str_functs[] = {
|
||||
{ERR_PACK(ERR_LIB_SM2, SM2_F_PKEY_SM2_CTRL, 0), "pkey_sm2_ctrl"},
|
||||
{ERR_PACK(ERR_LIB_SM2, SM2_F_PKEY_SM2_CTRL_STR, 0), "pkey_sm2_ctrl_str"},
|
||||
{ERR_PACK(ERR_LIB_SM2, SM2_F_PKEY_SM2_INIT, 0), "pkey_sm2_init"},
|
||||
{ERR_PACK(ERR_LIB_SM2, SM2_F_PKEY_SM2_SIGN, 0), "pkey_sm2_sign"},
|
||||
{ERR_PACK(ERR_LIB_SM2, SM2_F_SM2_COMPUTE_MSG_HASH, 0),
|
||||
"sm2_compute_msg_hash"},
|
||||
{ERR_PACK(ERR_LIB_SM2, SM2_F_SM2_COMPUTE_USERID_DIGEST, 0),
|
||||
@@ -31,11 +35,14 @@ static const ERR_STRING_DATA SM2_str_functs[] = {
|
||||
static const ERR_STRING_DATA SM2_str_reasons[] = {
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_ASN1_ERROR), "asn1 error"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_BAD_SIGNATURE), "bad signature"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_BUFFER_TOO_SMALL), "buffer too small"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_CURVE), "invalid curve"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_DIGEST), "invalid digest"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_DIGEST_TYPE),
|
||||
"invalid digest type"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_ENCODING), "invalid encoding"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_INVALID_FIELD), "invalid field"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_NO_PARAMETERS_SET), "no parameters set"},
|
||||
{ERR_PACK(ERR_LIB_SM2, 0, SM2_R_USER_ID_TOO_LARGE), "user id too large"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
@@ -0,0 +1,245 @@
|
||||
/*
|
||||
* Copyright 2006-2018 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 "internal/cryptlib.h"
|
||||
#include <openssl/asn1t.h>
|
||||
#include <openssl/ec.h>
|
||||
#include <openssl/evp.h>
|
||||
#include "internal/evp_int.h"
|
||||
#include "internal/sm2.h"
|
||||
#include "internal/sm2err.h"
|
||||
|
||||
/* EC pkey context structure */
|
||||
|
||||
typedef struct {
|
||||
/* Key and paramgen group */
|
||||
EC_GROUP *gen_group;
|
||||
/* message digest */
|
||||
const EVP_MD *md;
|
||||
} SM2_PKEY_CTX;
|
||||
|
||||
static int pkey_sm2_init(EVP_PKEY_CTX *ctx)
|
||||
{
|
||||
SM2_PKEY_CTX *dctx;
|
||||
|
||||
if ((dctx = OPENSSL_zalloc(sizeof(*dctx))) == NULL) {
|
||||
SM2err(SM2_F_PKEY_SM2_INIT, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ctx->data = dctx;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void pkey_sm2_cleanup(EVP_PKEY_CTX *ctx)
|
||||
{
|
||||
SM2_PKEY_CTX *dctx = ctx->data;
|
||||
|
||||
if (dctx != NULL) {
|
||||
EC_GROUP_free(dctx->gen_group);
|
||||
OPENSSL_free(dctx);
|
||||
ctx->data = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int pkey_sm2_copy(EVP_PKEY_CTX *dst, EVP_PKEY_CTX *src)
|
||||
{
|
||||
SM2_PKEY_CTX *dctx, *sctx;
|
||||
|
||||
if (!pkey_sm2_init(dst))
|
||||
return 0;
|
||||
sctx = src->data;
|
||||
dctx = dst->data;
|
||||
if (sctx->gen_group != NULL) {
|
||||
dctx->gen_group = EC_GROUP_dup(sctx->gen_group);
|
||||
if (dctx->gen_group == NULL) {
|
||||
pkey_sm2_cleanup(dst);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
dctx->md = sctx->md;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int pkey_sm2_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
|
||||
const unsigned char *tbs, size_t tbslen)
|
||||
{
|
||||
int ret;
|
||||
unsigned int sltmp;
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
const int sig_sz = ECDSA_size(ctx->pkey->pkey.ec);
|
||||
|
||||
if (sig_sz <= 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (sig == NULL) {
|
||||
*siglen = (size_t)sig_sz;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (*siglen < (size_t)sig_sz) {
|
||||
SM2err(SM2_F_PKEY_SM2_SIGN, SM2_R_BUFFER_TOO_SMALL);
|
||||
return 0;
|
||||
}
|
||||
|
||||
ret = sm2_sign(tbs, tbslen, sig, &sltmp, ec);
|
||||
|
||||
if (ret <= 0)
|
||||
return ret;
|
||||
*siglen = (size_t)sltmp;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int pkey_sm2_verify(EVP_PKEY_CTX *ctx,
|
||||
const unsigned char *sig, size_t siglen,
|
||||
const unsigned char *tbs, size_t tbslen)
|
||||
{
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
|
||||
return sm2_verify(tbs, tbslen, sig, siglen, ec);
|
||||
}
|
||||
|
||||
static int pkey_sm2_encrypt(EVP_PKEY_CTX *ctx,
|
||||
unsigned char *out, size_t *outlen,
|
||||
const unsigned char *in, size_t inlen)
|
||||
{
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
SM2_PKEY_CTX *dctx = ctx->data;
|
||||
const EVP_MD *md = (dctx->md == NULL) ? EVP_sm3() : dctx->md;
|
||||
|
||||
if (out == NULL) {
|
||||
if (!sm2_ciphertext_size(ec, md, inlen, outlen))
|
||||
return -1;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
return sm2_encrypt(ec, md, in, inlen, out, outlen);
|
||||
}
|
||||
|
||||
static int pkey_sm2_decrypt(EVP_PKEY_CTX *ctx,
|
||||
unsigned char *out, size_t *outlen,
|
||||
const unsigned char *in, size_t inlen)
|
||||
{
|
||||
EC_KEY *ec = ctx->pkey->pkey.ec;
|
||||
SM2_PKEY_CTX *dctx = ctx->data;
|
||||
const EVP_MD *md = (dctx->md == NULL) ? EVP_sm3() : dctx->md;
|
||||
|
||||
if (out == NULL) {
|
||||
if (!sm2_plaintext_size(ec, md, inlen, outlen))
|
||||
return -1;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
return sm2_decrypt(ec, md, in, inlen, out, outlen);
|
||||
}
|
||||
|
||||
static int pkey_sm2_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
|
||||
{
|
||||
SM2_PKEY_CTX *dctx = ctx->data;
|
||||
EC_GROUP *group;
|
||||
|
||||
switch (type) {
|
||||
case EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID:
|
||||
group = EC_GROUP_new_by_curve_name(p1);
|
||||
if (group == NULL) {
|
||||
SM2err(SM2_F_PKEY_SM2_CTRL, SM2_R_INVALID_CURVE);
|
||||
return 0;
|
||||
}
|
||||
EC_GROUP_free(dctx->gen_group);
|
||||
dctx->gen_group = group;
|
||||
return 1;
|
||||
|
||||
case EVP_PKEY_CTRL_EC_PARAM_ENC:
|
||||
if (dctx->gen_group == NULL) {
|
||||
SM2err(SM2_F_PKEY_SM2_CTRL, SM2_R_NO_PARAMETERS_SET);
|
||||
return 0;
|
||||
}
|
||||
EC_GROUP_set_asn1_flag(dctx->gen_group, p1);
|
||||
return 1;
|
||||
|
||||
case EVP_PKEY_CTRL_MD:
|
||||
dctx->md = p2;
|
||||
return 1;
|
||||
|
||||
case EVP_PKEY_CTRL_GET_MD:
|
||||
*(const EVP_MD **)p2 = dctx->md;
|
||||
return 1;
|
||||
|
||||
default:
|
||||
return -2;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
static int pkey_sm2_ctrl_str(EVP_PKEY_CTX *ctx,
|
||||
const char *type, const char *value)
|
||||
{
|
||||
if (strcmp(type, "ec_paramgen_curve") == 0) {
|
||||
int nid = NID_undef;
|
||||
|
||||
if (((nid = EC_curve_nist2nid(value)) == NID_undef)
|
||||
&& ((nid = OBJ_sn2nid(value)) == NID_undef)
|
||||
&& ((nid = OBJ_ln2nid(value)) == NID_undef)) {
|
||||
SM2err(SM2_F_PKEY_SM2_CTRL_STR, SM2_R_INVALID_CURVE);
|
||||
return 0;
|
||||
}
|
||||
return EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx, nid);
|
||||
} else if (strcmp(type, "ec_param_enc") == 0) {
|
||||
int param_enc;
|
||||
|
||||
if (strcmp(value, "explicit") == 0)
|
||||
param_enc = 0;
|
||||
else if (strcmp(value, "named_curve") == 0)
|
||||
param_enc = OPENSSL_EC_NAMED_CURVE;
|
||||
else
|
||||
return -2;
|
||||
return EVP_PKEY_CTX_set_ec_param_enc(ctx, param_enc);
|
||||
}
|
||||
|
||||
return -2;
|
||||
}
|
||||
|
||||
const EVP_PKEY_METHOD sm2_pkey_meth = {
|
||||
EVP_PKEY_SM2,
|
||||
0,
|
||||
pkey_sm2_init,
|
||||
pkey_sm2_copy,
|
||||
pkey_sm2_cleanup,
|
||||
|
||||
0,
|
||||
0,
|
||||
|
||||
0,
|
||||
0,
|
||||
|
||||
0,
|
||||
pkey_sm2_sign,
|
||||
|
||||
0,
|
||||
pkey_sm2_verify,
|
||||
|
||||
0, 0,
|
||||
|
||||
0, 0, 0, 0,
|
||||
|
||||
0,
|
||||
pkey_sm2_encrypt,
|
||||
|
||||
0,
|
||||
pkey_sm2_decrypt,
|
||||
|
||||
0,
|
||||
0,
|
||||
pkey_sm2_ctrl,
|
||||
pkey_sm2_ctrl_str
|
||||
};
|
||||
+2
-12
@@ -282,7 +282,7 @@ int sm2_do_verify(const EC_KEY *key,
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sm2_sign(int type, const unsigned char *dgst, int dgstlen,
|
||||
int sm2_sign(const unsigned char *dgst, int dgstlen,
|
||||
unsigned char *sig, unsigned int *siglen, EC_KEY *eckey)
|
||||
{
|
||||
BIGNUM *e = NULL;
|
||||
@@ -290,11 +290,6 @@ int sm2_sign(int type, const unsigned char *dgst, int dgstlen,
|
||||
int sigleni;
|
||||
int ret = -1;
|
||||
|
||||
if (type != NID_sm3 || dgstlen != 32) {
|
||||
SM2err(SM2_F_SM2_SIGN, SM2_R_INVALID_DIGEST_TYPE);
|
||||
goto done;
|
||||
}
|
||||
|
||||
e = BN_bin2bn(dgst, dgstlen, NULL);
|
||||
if (e == NULL) {
|
||||
SM2err(SM2_F_SM2_SIGN, ERR_R_BN_LIB);
|
||||
@@ -318,7 +313,7 @@ int sm2_sign(int type, const unsigned char *dgst, int dgstlen,
|
||||
return ret;
|
||||
}
|
||||
|
||||
int sm2_verify(int type, const unsigned char *dgst, int dgstlen,
|
||||
int sm2_verify(const unsigned char *dgst, int dgstlen,
|
||||
const unsigned char *sig, int sig_len, EC_KEY *eckey)
|
||||
{
|
||||
ECDSA_SIG *s = NULL;
|
||||
@@ -328,11 +323,6 @@ int sm2_verify(int type, const unsigned char *dgst, int dgstlen,
|
||||
int derlen = -1;
|
||||
int ret = -1;
|
||||
|
||||
if (type != NID_sm3) {
|
||||
SM2err(SM2_F_SM2_VERIFY, SM2_R_INVALID_DIGEST_TYPE);
|
||||
goto done;
|
||||
}
|
||||
|
||||
s = ECDSA_SIG_new();
|
||||
if (s == NULL) {
|
||||
SM2err(SM2_F_SM2_VERIFY, ERR_R_MALLOC_FAILURE);
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2014-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2014-2018 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
|
||||
|
||||
+37
-8
@@ -2,7 +2,9 @@
|
||||
|
||||
=head1 NAME
|
||||
|
||||
BN_rand, BN_pseudo_rand, BN_rand_range, BN_pseudo_rand_range - generate pseudo-random number
|
||||
BN_rand, BN_priv_rand, BN_pseudo_rand,
|
||||
BN_rand_range, BN_priv_rand_range, BN_pseudo_rand_range
|
||||
- generate pseudo-random number
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
@@ -10,10 +12,14 @@ BN_rand, BN_pseudo_rand, BN_rand_range, BN_pseudo_rand_range - generate pseudo-r
|
||||
|
||||
int BN_rand(BIGNUM *rnd, int bits, int top, int bottom);
|
||||
|
||||
int BN_priv_rand(BIGNUM *rnd, int bits, int top, int bottom);
|
||||
|
||||
int BN_pseudo_rand(BIGNUM *rnd, int bits, int top, int bottom);
|
||||
|
||||
int BN_rand_range(BIGNUM *rnd, BIGNUM *range);
|
||||
|
||||
int BN_priv_rand_range(BIGNUM *rnd, BIGNUM *range);
|
||||
|
||||
int BN_pseudo_rand_range(BIGNUM *rnd, BIGNUM *range);
|
||||
|
||||
=head1 DESCRIPTION
|
||||
@@ -37,7 +43,16 @@ If B<bits> is 1 then B<top> cannot also be B<BN_RAND_FLG_TOPTWO>.
|
||||
BN_rand_range() generates a cryptographically strong pseudo-random
|
||||
number B<rnd> in the range 0 E<lt>= B<rnd> E<lt> B<range>.
|
||||
|
||||
The PRNG must be seeded prior to calling BN_rand() or BN_rand_range().
|
||||
BN_priv_rand() and BN_priv_rand_range() have the same semantics as
|
||||
BN_rand() and BN_rand_range() respectively. They are intended to be
|
||||
used for generating values that should remain private, and mirror the
|
||||
same difference between L<RAND_bytes(3)> and L<RAND_priv_bytes(3)>.
|
||||
|
||||
=head1 NOTES
|
||||
|
||||
Always check the error return value of these functions and do not take
|
||||
randomness for granted: an error occurs if the CSPRNG has not been
|
||||
seeded with enough randomness to ensure an unpredictable byte sequence.
|
||||
|
||||
=head1 RETURN VALUES
|
||||
|
||||
@@ -46,20 +61,34 @@ The error codes can be obtained by L<ERR_get_error(3)>.
|
||||
|
||||
=head1 HISTORY
|
||||
|
||||
Starting with OpenSSL release 1.1.0,
|
||||
BN_pseudo_rand() has been identical to BN_rand()
|
||||
and
|
||||
BN_pseudo_rand_range() has been identical to BN_rand_range().
|
||||
=over 2
|
||||
|
||||
=item *
|
||||
|
||||
Starting with OpenSSL release 1.1.0, BN_pseudo_rand() has been identical
|
||||
to BN_rand() and BN_pseudo_rand_range() has been identical to
|
||||
BN_rand_range().
|
||||
The "pseudo" functions should not be used and may be deprecated in
|
||||
a future release.
|
||||
|
||||
=item *
|
||||
|
||||
BN_priv_rand() and BN_priv_rand_range() were added in OpenSSL 1.1.1.
|
||||
|
||||
=back
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
L<ERR_get_error(3)>, L<RAND_add(3)>, L<RAND_bytes(3)>
|
||||
L<ERR_get_error(3)>,
|
||||
L<RAND_add(3)>,
|
||||
L<RAND_bytes(3)>,
|
||||
L<RAND_priv_bytes(3)>,
|
||||
L<RAND(7)>,
|
||||
L<RAND_DRBG(7)>
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
Copyright 2000-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
Copyright 2000-2018 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
|
||||
|
||||
@@ -65,7 +65,7 @@ BUF_MEM_new_ex() was added in OpenSSL 1.1.0.
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
Copyright 2000-2018 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
|
||||
|
||||
@@ -58,7 +58,7 @@ L<DSA_do_sign(3)>
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
Copyright 2000-2018 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
|
||||
|
||||
@@ -316,7 +316,7 @@ OBJECT IDENTIFIER or NID_undef if it has no defined OBJECT IDENTIFIER.
|
||||
EVP_CIPHER_CTX_cipher() returns an B<EVP_CIPHER> structure.
|
||||
|
||||
EVP_CIPHER_param_to_asn1() and EVP_CIPHER_asn1_to_param() return greater
|
||||
than zero for success and zero or a negative number.
|
||||
than zero for success and zero or a negative number on failure.
|
||||
|
||||
EVP_CIPHER_CTX_rand_key() returns 1 for success.
|
||||
|
||||
|
||||
@@ -7,7 +7,7 @@ EVP_PKEY_get1_RSA, EVP_PKEY_get1_DSA, EVP_PKEY_get1_DH, EVP_PKEY_get1_EC_KEY,
|
||||
EVP_PKEY_get0_RSA, EVP_PKEY_get0_DSA, EVP_PKEY_get0_DH, EVP_PKEY_get0_EC_KEY,
|
||||
EVP_PKEY_assign_RSA, EVP_PKEY_assign_DSA, EVP_PKEY_assign_DH,
|
||||
EVP_PKEY_assign_EC_KEY, EVP_PKEY_get0_hmac, EVP_PKEY_type, EVP_PKEY_id,
|
||||
EVP_PKEY_base_id, EVP_PKEY_set1_engine - EVP_PKEY assignment functions
|
||||
EVP_PKEY_base_id, EVP_PKEY_set_alias_type, EVP_PKEY_set1_engine - EVP_PKEY assignment functions
|
||||
|
||||
=head1 SYNOPSIS
|
||||
|
||||
@@ -37,6 +37,7 @@ EVP_PKEY_base_id, EVP_PKEY_set1_engine - EVP_PKEY assignment functions
|
||||
int EVP_PKEY_id(const EVP_PKEY *pkey);
|
||||
int EVP_PKEY_base_id(const EVP_PKEY *pkey);
|
||||
int EVP_PKEY_type(int type);
|
||||
int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type);
|
||||
|
||||
int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *engine);
|
||||
|
||||
@@ -78,6 +79,10 @@ must be called after the key algorithm and components are set up.
|
||||
If B<engine> does not include an B<EVP_PKEY_METHOD> for B<pkey> an
|
||||
error occurs.
|
||||
|
||||
EVP_PKEY_set_alias_type() allows modifying a EVP_PKEY to use a
|
||||
different set of algorithms than the default. This is currently used
|
||||
to support SM2 keys, which use an identical encoding to ECDSA.
|
||||
|
||||
=head1 NOTES
|
||||
|
||||
In accordance with the OpenSSL naming convention the key obtained
|
||||
@@ -98,6 +103,13 @@ is no longer possible: the equivalent is EVP_PKEY_base_id(pkey).
|
||||
EVP_PKEY_set1_engine() is typically used by an ENGINE returning an HSM
|
||||
key as part of its routine to load a private key.
|
||||
|
||||
=head1 EXAMPLES
|
||||
|
||||
After loading an ECC key, it is possible to convert it to using SM2
|
||||
algorithms with EVP_PKEY_set_alias_type:
|
||||
|
||||
EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2);
|
||||
|
||||
=head1 RETURN VALUES
|
||||
|
||||
EVP_PKEY_set1_RSA(), EVP_PKEY_set1_DSA(), EVP_PKEY_set1_DH() and
|
||||
@@ -115,13 +127,15 @@ type or B<NID_undef> (equivalently B<EVP_PKEY_NONE>) on error.
|
||||
|
||||
EVP_PKEY_set1_engine() returns 1 for success and 0 for failure.
|
||||
|
||||
EVP_PKEY_set_alias_type() returns 1 for success and 0 for error.
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
L<EVP_PKEY_new(3)>
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
Copyright 2002-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
Copyright 2002-2018 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
|
||||
|
||||
@@ -236,7 +236,7 @@ type checking.
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
Copyright 2000-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
Copyright 2000-2018 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
|
||||
|
||||
@@ -22,7 +22,8 @@ the structure and B<cert> its corresponding certificates. B<ca>, if not B<NULL>
|
||||
is an optional set of certificates to also include in the structure.
|
||||
|
||||
B<nid_key> and B<nid_cert> are the encryption algorithms that should be used
|
||||
for the key and certificate respectively. B<iter> is the encryption algorithm
|
||||
for the key and certificate respectively. The modes
|
||||
GCM, CCM, XTS, and OCB are unsupported. B<iter> is the encryption algorithm
|
||||
iteration count to use and B<mac_iter> is the MAC iteration count to use.
|
||||
B<keytype> is the type of key.
|
||||
|
||||
|
||||
+26
-6
@@ -20,13 +20,21 @@ Deprecated:
|
||||
=head1 DESCRIPTION
|
||||
|
||||
RAND_bytes() puts B<num> cryptographically strong pseudo-random bytes
|
||||
into B<buf>. An error occurs if the CSPRNG has not been seeded with
|
||||
enough randomness to ensure an unpredictable byte sequence.
|
||||
into B<buf>.
|
||||
|
||||
RAND_priv_bytes() has the same semantics as RAND_bytes(). It is intended to
|
||||
be used for generating long-term private keys. If using the default
|
||||
RAND_METHOD, this function uses a separate instance of the PRNG so that
|
||||
a compromise of the global generator will not affect such key generation.
|
||||
be used for generating values that should remain private. If using the
|
||||
default RAND_METHOD, this function uses a separate "private" PRNG
|
||||
instance so that a compromise of the "public" PRNG instance will not
|
||||
affect the secrecy of these private values, as described in L<RAND(7)>
|
||||
and L<RAND_DRBG(7)>.
|
||||
|
||||
=head1 NOTES
|
||||
|
||||
Always check the error return value of RAND_bytes() and
|
||||
RAND_priv_bytes() and do not take randomness for granted: an error occurs
|
||||
if the CSPRNG has not been seeded with enough randomness to ensure an
|
||||
unpredictable byte sequence.
|
||||
|
||||
=head1 RETURN VALUES
|
||||
|
||||
@@ -37,14 +45,26 @@ obtained by L<ERR_get_error(3)>.
|
||||
|
||||
=head1 HISTORY
|
||||
|
||||
=over 2
|
||||
|
||||
=item *
|
||||
|
||||
RAND_pseudo_bytes() was deprecated in OpenSSL 1.1.0; use RAND_bytes() instead.
|
||||
|
||||
=item *
|
||||
|
||||
RAND_priv_bytes() was added in OpenSSL 1.1.1.
|
||||
|
||||
=back
|
||||
|
||||
=head1 SEE ALSO
|
||||
|
||||
L<RAND_add(3)>,
|
||||
L<RAND_bytes(3)>,
|
||||
L<RAND_priv_bytes(3)>,
|
||||
L<ERR_get_error(3)>,
|
||||
L<RAND(7)>
|
||||
L<RAND(7)>,
|
||||
L<RAND_DRBG(7)>
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
|
||||
@@ -43,9 +43,9 @@ L<SSL_CTX_set_session_cache_mode(3)>).
|
||||
(SSL/TLS server only.)
|
||||
|
||||
SSL_CTX_sess_get_new_cb(), SSL_CTX_sess_get_remove_cb(), and
|
||||
SSL_CTX_sess_get_get_cb() allow to retrieve the function pointers of the
|
||||
provided callback functions. If a callback function has not been set,
|
||||
the NULL pointer is returned.
|
||||
SSL_CTX_sess_get_get_cb() retrieve the function pointers set by the
|
||||
corresponding set callback functions. If a callback function has not been
|
||||
set, the NULL pointer is returned.
|
||||
|
||||
=head1 NOTES
|
||||
|
||||
|
||||
@@ -34,10 +34,10 @@ argument I<arg> is specified by the application when setting I<callback>.
|
||||
I<callback> should return 1 to indicate verification success and 0 to
|
||||
indicate verification failure. If SSL_VERIFY_PEER is set and I<callback>
|
||||
returns 0, the handshake will fail. As the verification procedure may
|
||||
allow to continue the connection in case of failure (by always returning 1)
|
||||
the verification result must be set in any case using the B<error>
|
||||
member of I<x509_store_ctx> so that the calling application will be informed
|
||||
about the detailed result of the verification procedure!
|
||||
allow the connection to continue in the case of failure (by always
|
||||
returning 1) the verification result must be set in any case using the
|
||||
B<error> member of I<x509_store_ctx> so that the calling application
|
||||
will be informed about the detailed result of the verification procedure!
|
||||
|
||||
Within I<x509_store_ctx>, I<callback> has access to the I<verify_callback>
|
||||
function set using L<SSL_CTX_set_verify(3)>.
|
||||
|
||||
@@ -61,7 +61,7 @@ L<ssl(7)>, L<SSL_CIPHER_get_name(3)>
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
Copyright 2000-2018 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
|
||||
|
||||
@@ -155,7 +155,7 @@ B<X509_CHECK_FLAG_NEVER_CHECK_SUBJECT> host flag, or because some DNS subject
|
||||
alternative names are present in the certificate, DNS name constraints in
|
||||
issuer certificates will not be applied to the subject DN.
|
||||
As described in X509_check_host(3) the B<X509_CHECK_FLAG_NEVER_CHECK_SUBJECT>
|
||||
flag takes precendence over the B<X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT> flag.
|
||||
flag takes precedence over the B<X509_CHECK_FLAG_ALWAYS_CHECK_SUBJECT> flag.
|
||||
|
||||
X509_VERIFY_PARAM_get_hostflags() returns any host flags previously set via a
|
||||
call to X509_VERIFY_PARAM_set_hostflags().
|
||||
|
||||
@@ -132,7 +132,7 @@ L<X509V3_get_d2i(3)>
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
Copyright 2015-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
Copyright 2015-2018 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
|
||||
|
||||
+12
-9
@@ -24,16 +24,19 @@ to be initialized ('seeded') explicitly.
|
||||
It seeds and reseeds itself automatically using trusted random sources
|
||||
provided by the operating system.
|
||||
|
||||
As a normal application developer, you don't have to worry about any details,
|
||||
As a normal application developer, you do not have to worry about any details,
|
||||
just use L<RAND_bytes(3)> to obtain random data.
|
||||
Having said that, there is one important rule to obey: Always check the error
|
||||
return value of L<RAND_bytes(3)> and don't take randomness for granted.
|
||||
return value of L<RAND_bytes(3)> and do not take randomness for granted.
|
||||
|
||||
For long-term secrets, you can use L<RAND_priv_bytes(3)> instead.
|
||||
For values that should remain secret, you can use L<RAND_priv_bytes(3)>
|
||||
instead.
|
||||
This method does not provide 'better' randomness, it uses the same type of CSPRNG.
|
||||
The intention behind using a dedicated CSPRNG exclusively for long-term secrets is
|
||||
that none of its output should be visible to an attacker (e.g used as salt value),
|
||||
in order to reveal as little information as possible about its internal state.
|
||||
The intention behind using a dedicated CSPRNG exclusively for private
|
||||
values is that none of its output should be visible to an attacker (e.g.,
|
||||
used as salt value), in order to reveal as little information as
|
||||
possible about its internal state, and that a compromise of the "public"
|
||||
CSPRNG instance will not affect the secrecy of these private values.
|
||||
|
||||
In the rare case where the default implementation does not satisfy your special
|
||||
requirements, there are two options:
|
||||
@@ -61,10 +64,10 @@ of cryptographic principles and understand the implications of your changes.
|
||||
L<RAND_add(3)>,
|
||||
L<RAND_bytes(3)>,
|
||||
L<RAND_priv_bytes(3)>,
|
||||
L<RAND_get_rand_method(3)>
|
||||
L<RAND_set_rand_method(3)>
|
||||
L<RAND_get_rand_method(3)>,
|
||||
L<RAND_set_rand_method(3)>,
|
||||
L<RAND_OpenSSL(3)>,
|
||||
L<RAND_DRBG(7)>,
|
||||
L<RAND_DRBG(7)>
|
||||
|
||||
=head1 COPYRIGHT
|
||||
|
||||
|
||||
@@ -222,7 +222,7 @@ This is in fact done automatically by L<RAND_DRBG_bytes(3)>.
|
||||
|
||||
In most cases OpenSSL will automatically choose a suitable seed source
|
||||
for automatically seeding and reseeding its <master> DRBG. In some cases
|
||||
however, it will be necessary to explicitely specify a seed source during
|
||||
however, it will be necessary to explicitly specify a seed source during
|
||||
configuration, using the --with-rand-seed option. For more information,
|
||||
see the INSTALL instructions. There are also operating systems where no
|
||||
seed source is available and automatic reseeding is disabled by default.
|
||||
|
||||
@@ -241,6 +241,7 @@ int ERR_load_ASN1_strings(void);
|
||||
# define ASN1_R_UNKNOWN_SIGNATURE_ALGORITHM 199
|
||||
# define ASN1_R_UNKNOWN_TAG 194
|
||||
# define ASN1_R_UNSUPPORTED_ANY_DEFINED_BY_TYPE 164
|
||||
# define ASN1_R_UNSUPPORTED_CIPHER 228
|
||||
# define ASN1_R_UNSUPPORTED_PUBLIC_KEY_TYPE 167
|
||||
# define ASN1_R_UNSUPPORTED_TYPE 196
|
||||
# define ASN1_R_WRONG_INTEGER_TYPE 225
|
||||
|
||||
@@ -99,7 +99,7 @@ int DSA_size(const DSA *);
|
||||
int DSA_bits(const DSA *d);
|
||||
int DSA_security_bits(const DSA *d);
|
||||
/* next 4 return -1 on error */
|
||||
int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp);
|
||||
DEPRECATEDIN_1_2_0(int DSA_sign_setup(DSA *dsa, BN_CTX *ctx_in, BIGNUM **kinvp, BIGNUM **rp))
|
||||
int DSA_sign(int type, const unsigned char *dgst, int dlen,
|
||||
unsigned char *sig, unsigned int *siglen, DSA *dsa);
|
||||
int DSA_verify(int type, const unsigned char *dgst, int dgst_len,
|
||||
|
||||
@@ -87,6 +87,7 @@ int ERR_load_EC_strings(void);
|
||||
# define EC_F_EC_GFP_NIST_FIELD_MUL 200
|
||||
# define EC_F_EC_GFP_NIST_FIELD_SQR 201
|
||||
# define EC_F_EC_GFP_NIST_GROUP_SET_CURVE 202
|
||||
# define EC_F_EC_GFP_SIMPLE_BLIND_COORDINATES 287
|
||||
# define EC_F_EC_GFP_SIMPLE_GROUP_CHECK_DISCRIMINANT 165
|
||||
# define EC_F_EC_GFP_SIMPLE_GROUP_SET_CURVE 166
|
||||
# define EC_F_EC_GFP_SIMPLE_MAKE_AFFINE 102
|
||||
@@ -182,6 +183,12 @@ int ERR_load_EC_strings(void);
|
||||
# define EC_F_PKEY_EC_KEYGEN 199
|
||||
# define EC_F_PKEY_EC_PARAMGEN 219
|
||||
# define EC_F_PKEY_EC_SIGN 218
|
||||
# define EC_F_PKEY_SM2_CTRL 284
|
||||
# define EC_F_PKEY_SM2_CTRL_STR 285
|
||||
# define EC_F_PKEY_SM2_INIT 287
|
||||
# define EC_F_PKEY_SM2_KEYGEN 288
|
||||
# define EC_F_PKEY_SM2_PARAMGEN 289
|
||||
# define EC_F_PKEY_SM2_SIGN 290
|
||||
# define EC_F_VALIDATE_ECX_DERIVE 278
|
||||
|
||||
/*
|
||||
|
||||
@@ -995,6 +995,7 @@ int EVP_PKEY_security_bits(const EVP_PKEY *pkey);
|
||||
int EVP_PKEY_size(EVP_PKEY *pkey);
|
||||
int EVP_PKEY_set_type(EVP_PKEY *pkey, int type);
|
||||
int EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len);
|
||||
int EVP_PKEY_set_alias_type(EVP_PKEY *pkey, int type);
|
||||
# ifndef OPENSSL_NO_ENGINE
|
||||
int EVP_PKEY_set1_engine(EVP_PKEY *pkey, ENGINE *e);
|
||||
# endif
|
||||
|
||||
@@ -38,9 +38,11 @@ int ERR_load_EVP_strings(void);
|
||||
# define EVP_F_DO_SIGVER_INIT 161
|
||||
# define EVP_F_ENC_NEW 199
|
||||
# define EVP_F_EVP_CIPHERINIT_EX 123
|
||||
# define EVP_F_EVP_CIPHER_ASN1_TO_PARAM 204
|
||||
# define EVP_F_EVP_CIPHER_CTX_COPY 163
|
||||
# define EVP_F_EVP_CIPHER_CTX_CTRL 124
|
||||
# define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH 122
|
||||
# define EVP_F_EVP_CIPHER_PARAM_TO_ASN1 205
|
||||
# define EVP_F_EVP_DECRYPTFINAL_EX 101
|
||||
# define EVP_F_EVP_DECRYPTUPDATE 166
|
||||
# define EVP_F_EVP_DIGESTFINALXOF 174
|
||||
@@ -94,6 +96,7 @@ int ERR_load_EVP_strings(void);
|
||||
# define EVP_F_EVP_PKEY_PARAM_CHECK 189
|
||||
# define EVP_F_EVP_PKEY_PUBLIC_CHECK 190
|
||||
# define EVP_F_EVP_PKEY_SET1_ENGINE 187
|
||||
# define EVP_F_EVP_PKEY_SET_ALIAS_TYPE 206
|
||||
# define EVP_F_EVP_PKEY_SIGN 140
|
||||
# define EVP_F_EVP_PKEY_SIGN_INIT 141
|
||||
# define EVP_F_EVP_PKEY_VERIFY 142
|
||||
|
||||
@@ -68,9 +68,7 @@ extern "C" {
|
||||
* still won't see them if the library has been built to disable deprecated
|
||||
* functions.
|
||||
*/
|
||||
#if defined(OPENSSL_NO_DEPRECATED)
|
||||
# define DECLARE_DEPRECATED(f)
|
||||
#elif __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
|
||||
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ > 0)
|
||||
# define DECLARE_DEPRECATED(f) f __attribute__ ((deprecated));
|
||||
#else
|
||||
# define DECLARE_DEPRECATED(f) f;
|
||||
|
||||
@@ -39,8 +39,8 @@ extern "C" {
|
||||
* (Prior to 0.9.5a beta1, a different scheme was used: MMNNFFRBB for
|
||||
* major minor fix final patch/beta)
|
||||
*/
|
||||
# define OPENSSL_VERSION_NUMBER 0x10101008L
|
||||
# define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1-pre8-dev xx XXX xxxx"
|
||||
# define OPENSSL_VERSION_NUMBER 0x10101009L
|
||||
# define OPENSSL_VERSION_TEXT "OpenSSL 1.1.1-pre9-dev xx XXX xxxx"
|
||||
|
||||
/*-
|
||||
* The macros below are to be used for shared library (.so, .dll, ...)
|
||||
|
||||
@@ -1573,6 +1573,9 @@ int ssl3_read_bytes(SSL *s, int type, int *recvd_type, unsigned char *buf,
|
||||
SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_SSL3_READ_BYTES,
|
||||
SSL_R_NO_RENEGOTIATION);
|
||||
return -1;
|
||||
} else if (alert_level == SSL3_AL_WARNING) {
|
||||
/* We ignore any other warning alert in TLSv1.2 and below */
|
||||
goto start;
|
||||
}
|
||||
|
||||
SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_SSL3_READ_BYTES,
|
||||
|
||||
+6
-4
@@ -328,7 +328,8 @@ SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
|
||||
|
||||
ret->ext.tick_lifetime_hint = (unsigned long)as->tlsext_tick_lifetime_hint;
|
||||
ret->ext.tick_age_add = as->tlsext_tick_age_add;
|
||||
if (as->tlsext_tick) {
|
||||
OPENSSL_free(ret->ext.tick);
|
||||
if (as->tlsext_tick != NULL) {
|
||||
ret->ext.tick = as->tlsext_tick->data;
|
||||
ret->ext.ticklen = as->tlsext_tick->length;
|
||||
as->tlsext_tick->data = NULL;
|
||||
@@ -355,11 +356,11 @@ SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
|
||||
ret->flags = (int32_t)as->flags;
|
||||
ret->ext.max_early_data = as->max_early_data;
|
||||
|
||||
OPENSSL_free(ret->ext.alpn_selected);
|
||||
if (as->alpn_selected != NULL) {
|
||||
if (!ssl_session_strndup((char **)&ret->ext.alpn_selected,
|
||||
as->alpn_selected))
|
||||
goto err;
|
||||
ret->ext.alpn_selected = as->alpn_selected->data;
|
||||
ret->ext.alpn_selected_len = as->alpn_selected->length;
|
||||
as->alpn_selected->data = NULL;
|
||||
} else {
|
||||
ret->ext.alpn_selected = NULL;
|
||||
ret->ext.alpn_selected_len = 0;
|
||||
@@ -367,6 +368,7 @@ SSL_SESSION *d2i_SSL_SESSION(SSL_SESSION **a, const unsigned char **pp,
|
||||
|
||||
ret->ext.max_fragment_len_mode = as->tlsext_max_fragment_len_mode;
|
||||
|
||||
OPENSSL_free(ret->ticket_appdata);
|
||||
if (as->ticket_appdata != NULL) {
|
||||
ret->ticket_appdata = as->ticket_appdata->data;
|
||||
ret->ticket_appdata_len = as->ticket_appdata->length;
|
||||
|
||||
+4
-6
@@ -220,13 +220,11 @@ SSL_SESSION *ssl_session_dup(SSL_SESSION *src, int ticket)
|
||||
dest->ext.ticklen = 0;
|
||||
}
|
||||
|
||||
if (src->ext.alpn_selected) {
|
||||
dest->ext.alpn_selected =
|
||||
(unsigned char*)OPENSSL_strndup((char*)src->ext.alpn_selected,
|
||||
src->ext.alpn_selected_len);
|
||||
if (dest->ext.alpn_selected == NULL) {
|
||||
if (src->ext.alpn_selected != NULL) {
|
||||
dest->ext.alpn_selected = OPENSSL_memdup(src->ext.alpn_selected,
|
||||
src->ext.alpn_selected_len);
|
||||
if (dest->ext.alpn_selected == NULL)
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_SRP
|
||||
|
||||
+125
-1
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2015-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2015-2018 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
|
||||
@@ -477,6 +477,127 @@ static int test_EVP_PKCS82PKEY(void)
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifndef OPENSSL_NO_SM2
|
||||
|
||||
static int test_EVP_SM2(void)
|
||||
{
|
||||
int ret = 0;
|
||||
EVP_PKEY *pkey = NULL;
|
||||
EVP_PKEY *params = NULL;
|
||||
EVP_PKEY_CTX *pctx = NULL;
|
||||
EVP_PKEY_CTX *kctx = NULL;
|
||||
size_t sig_len = 0;
|
||||
unsigned char *sig = NULL;
|
||||
EVP_MD_CTX *md_ctx = NULL;
|
||||
EVP_MD_CTX *md_ctx_verify = NULL;
|
||||
EVP_PKEY_CTX *cctx = NULL;
|
||||
|
||||
uint8_t ciphertext[128];
|
||||
size_t ctext_len = sizeof(ciphertext);
|
||||
|
||||
uint8_t plaintext[8];
|
||||
size_t ptext_len = sizeof(plaintext);
|
||||
|
||||
pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
|
||||
if (!TEST_ptr(pctx))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_paramgen_init(pctx) == 1))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx, NID_sm2)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_paramgen(pctx, ¶ms)))
|
||||
goto done;
|
||||
|
||||
kctx = EVP_PKEY_CTX_new(params, NULL);
|
||||
if (!TEST_ptr(kctx))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_keygen_init(kctx)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_keygen(kctx, &pkey)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_ptr(md_ctx = EVP_MD_CTX_new()))
|
||||
goto done;
|
||||
|
||||
if (!TEST_ptr(md_ctx_verify = EVP_MD_CTX_new()))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_DigestSignInit(md_ctx, NULL, EVP_sm3(), NULL, pkey)))
|
||||
goto done;
|
||||
|
||||
if(!TEST_true(EVP_DigestSignUpdate(md_ctx, kMsg, sizeof(kMsg))))
|
||||
goto done;
|
||||
|
||||
/* Determine the size of the signature. */
|
||||
if (!TEST_true(EVP_DigestSignFinal(md_ctx, NULL, &sig_len)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_size_t_eq(sig_len, (size_t)EVP_PKEY_size(pkey)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_ptr(sig = OPENSSL_malloc(sig_len)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_DigestSignFinal(md_ctx, sig, &sig_len)))
|
||||
goto done;
|
||||
|
||||
/* Ensure that the signature round-trips. */
|
||||
|
||||
if (!TEST_true(EVP_DigestVerifyInit(md_ctx_verify, NULL, EVP_sm3(), NULL, pkey)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_DigestVerifyUpdate(md_ctx_verify, kMsg, sizeof(kMsg))))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_DigestVerifyFinal(md_ctx_verify, sig, sig_len)))
|
||||
goto done;
|
||||
|
||||
/* now check encryption/decryption */
|
||||
|
||||
if (!TEST_ptr(cctx = EVP_PKEY_CTX_new(pkey, NULL)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_encrypt_init(cctx)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_encrypt(cctx, ciphertext, &ctext_len, kMsg, sizeof(kMsg))))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_decrypt_init(cctx)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(EVP_PKEY_decrypt(cctx, plaintext, &ptext_len, ciphertext, ctext_len)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(ptext_len == sizeof(kMsg)))
|
||||
goto done;
|
||||
|
||||
if (!TEST_true(memcmp(plaintext, kMsg, sizeof(kMsg)) == 0))
|
||||
goto done;
|
||||
|
||||
ret = 1;
|
||||
done:
|
||||
EVP_PKEY_CTX_free(pctx);
|
||||
EVP_PKEY_CTX_free(kctx);
|
||||
EVP_PKEY_CTX_free(cctx);
|
||||
EVP_PKEY_free(pkey);
|
||||
EVP_PKEY_free(params);
|
||||
EVP_MD_CTX_free(md_ctx);
|
||||
EVP_MD_CTX_free(md_ctx_verify);
|
||||
OPENSSL_free(sig);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
static struct keys_st {
|
||||
int type;
|
||||
char *priv;
|
||||
@@ -663,6 +784,9 @@ int setup_tests(void)
|
||||
ADD_ALL_TESTS(test_d2i_AutoPrivateKey, OSSL_NELEM(keydata));
|
||||
#ifndef OPENSSL_NO_EC
|
||||
ADD_TEST(test_EVP_PKCS82PKEY);
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_SM2
|
||||
ADD_TEST(test_EVP_SM2);
|
||||
#endif
|
||||
ADD_ALL_TESTS(test_set_get_raw_keys, OSSL_NELEM(keys));
|
||||
custom_pmeth = EVP_PKEY_meth_new(0xdefaced, 0);
|
||||
|
||||
+11
-21
@@ -2413,23 +2413,6 @@ static char *take_value(PAIR *pp)
|
||||
return p;
|
||||
}
|
||||
|
||||
static int key_disabled(EVP_PKEY *pkey)
|
||||
{
|
||||
#if defined(OPENSSL_NO_SM2) && !defined(OPENSSL_NO_EC)
|
||||
int type = EVP_PKEY_base_id(pkey);
|
||||
|
||||
if (type == EVP_PKEY_EC) {
|
||||
EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);
|
||||
int nid = EC_GROUP_get_curve_name(EC_KEY_get0_group(ec));
|
||||
|
||||
if (nid == NID_sm2)
|
||||
return 1;
|
||||
}
|
||||
#endif /* OPENSSL_NO_SM2 */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read and parse one test. Return 0 if failure, 1 if okay.
|
||||
*/
|
||||
@@ -2516,10 +2499,6 @@ top:
|
||||
}
|
||||
OPENSSL_free(keybin);
|
||||
}
|
||||
if (pkey != NULL && key_disabled(pkey)) {
|
||||
EVP_PKEY_free(pkey);
|
||||
pkey = NULL;
|
||||
}
|
||||
|
||||
/* If we have a key add to list */
|
||||
if (klist != NULL) {
|
||||
@@ -2530,6 +2509,17 @@ top:
|
||||
if (!TEST_ptr(key = OPENSSL_malloc(sizeof(*key))))
|
||||
return 0;
|
||||
key->name = take_value(pp);
|
||||
|
||||
/* Hack to detect SM2 keys */
|
||||
if(pkey != NULL && strstr(key->name, "SM2") != NULL) {
|
||||
#ifdef OPENSSL_NO_SM2
|
||||
EVP_PKEY_free(pkey);
|
||||
pkey = NULL;
|
||||
#else
|
||||
EVP_PKEY_set_alias_type(pkey, EVP_PKEY_SM2);
|
||||
#endif
|
||||
}
|
||||
|
||||
key->key = pkey;
|
||||
key->next = *klist;
|
||||
*klist = key;
|
||||
|
||||
@@ -17257,6 +17257,35 @@ PeerKey=KAS-ECC-CDH_B-571_C24-Peer-PUBLIC
|
||||
Ctrl=ecdh_cofactor_mode:1
|
||||
SharedSecret=02da266a269bdc8d8b2a0c6bb5762f102fc801c8d5394a9271539136bd81d4b69cfbb7525cd0a983fb7f7e9deec583b8f8e574c6184b2d79831ec770649e484dc006fa35b0bffd0b
|
||||
|
||||
# for cofactor-order points, ECC CDH (co-factor ECDH) should fail. Test that.
|
||||
|
||||
PrivateKey=ALICE_cf_sect283k1
|
||||
-----BEGIN PRIVATE KEY-----
|
||||
MIGQAgEAMBAGByqGSM49AgEGBSuBBAAQBHkwdwIBAQQkAHtPwRfQZ9pWgSctyHdt
|
||||
xt3pd8ESMI3ugVx8MDLkiVB8GkCRoUwDSgAEA+xpY5sDcgM2yYxoWOrzH7WUH+b3
|
||||
n68A32kODgcKu8PXRYEKBH8Xzbr974982ZJW1sGrDs+P81sIFH8tdp45Jkr+OtfM
|
||||
8uKr
|
||||
-----END PRIVATE KEY-----
|
||||
|
||||
PublicKey=ALICE_cf_sect283k1_PUB
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MF4wEAYHKoZIzj0CAQYFK4EEABADSgAEA+xpY5sDcgM2yYxoWOrzH7WUH+b3n68A
|
||||
32kODgcKu8PXRYEKBH8Xzbr974982ZJW1sGrDs+P81sIFH8tdp45Jkr+OtfM8uKr
|
||||
-----END PUBLIC KEY-----
|
||||
|
||||
PublicKey=BOB_cf_sect283k1_PUB
|
||||
-----BEGIN PUBLIC KEY-----
|
||||
MF4wEAYHKoZIzj0CAQYFK4EEABADSgAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
|
||||
AAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB
|
||||
-----END PUBLIC KEY-----
|
||||
|
||||
PrivPubKeyPair = ALICE_cf_sect283k1:ALICE_cf_sect283k1_PUB
|
||||
|
||||
# ECDH Alice with Bob peer
|
||||
Derive=ALICE_cf_sect283k1
|
||||
PeerKey=BOB_cf_sect283k1_PUB
|
||||
Ctrl=ecdh_cofactor_mode:1
|
||||
Result = DERIVE_ERROR
|
||||
|
||||
Title = Test keypair mistmatches
|
||||
|
||||
@@ -18384,6 +18413,16 @@ Ctrl = digest:SM3
|
||||
Input = D7AD397F6FFA5D4F7F11E7217F241607DC30618C236D2C09C1B9EA8FDADEE2E8
|
||||
Output = 3046022100AB1DB64DE7C40EDBDE6651C9B8EBDB804673DB836E5D5C7FE15DCF9ED2725037022100EBA714451FF69B0BB930B379E192E7CD5FA6E3C41C7FBD8303B799AB54A54621
|
||||
|
||||
Verify = SM2_key1
|
||||
Ctrl = digest:SM3
|
||||
Input = B1139602C6ECC9E15E2F3F9C635A1AFE737058BC15387479C1EA0D0B3D90E9E5
|
||||
Output = 3045022100E6E0414EBD3A656C35602AF14AB20287DBF30D57AF75C49A188ED4B42391F22402202F54F277C606F4605E1CE9514947FFDDF94C67A539804A4ED17F852288BDBE2E
|
||||
|
||||
Verify = SM2_key1
|
||||
Ctrl = digest:SHA512
|
||||
Input = 40AA1B203C9D8EE150B21C3C7CDA8261492E5420C5F2B9F7380700E094C303B48E62F319C1DA0E32EB40D113C5F1749CC61AEB499167890AB82F2CC9BB706971
|
||||
Output = 3046022100AE018933B9BA041784380069F2DDF609694DCD299FDBF23D09F4B711FBC103EC0221008440BB1A48C132DE4FB91BE9F43B958142FDD29FB9DABE01B17514023A2F638C
|
||||
|
||||
Decrypt = SM2_key1
|
||||
Input = 30818A0220466BE2EF5C11782EC77864A0055417F407A5AFC11D653C6BCE69E417BB1D05B6022062B572E21FF0DDF5C726BD3F9FF2EAE56E6294713A607E9B9525628965F62CC804203C1B5713B5DB2728EB7BF775E44F4689FC32668BDC564F52EA45B09E8DF2A5F40422084A9D0CC2997092B7D3C404FCE95956EB604D732B2307A8E5B8900ED6608CA5B197
|
||||
Output = "The floofy bunnies hop at midnight"
|
||||
|
||||
@@ -28,6 +28,7 @@ static const RAND_METHOD *saved_rand;
|
||||
|
||||
static uint8_t *fake_rand_bytes = NULL;
|
||||
static size_t fake_rand_bytes_offset = 0;
|
||||
static size_t fake_rand_size = 0;
|
||||
|
||||
static int get_faked_bytes(unsigned char *buf, int num)
|
||||
{
|
||||
@@ -36,6 +37,9 @@ static int get_faked_bytes(unsigned char *buf, int num)
|
||||
if (fake_rand_bytes == NULL)
|
||||
return saved_rand->bytes(buf, num);
|
||||
|
||||
if (!TEST_size_t_le(fake_rand_bytes_offset + num, fake_rand_size))
|
||||
return 0;
|
||||
|
||||
for (i = 0; i != num; ++i)
|
||||
buf[i] = fake_rand_bytes[fake_rand_bytes_offset + i];
|
||||
fake_rand_bytes_offset += num;
|
||||
@@ -54,6 +58,7 @@ static int start_fake_rand(const char *hex_bytes)
|
||||
|
||||
fake_rand_bytes = OPENSSL_hexstr2buf(hex_bytes, NULL);
|
||||
fake_rand_bytes_offset = 0;
|
||||
fake_rand_size = strlen(hex_bytes) / 2;
|
||||
|
||||
/* set new RAND_METHOD */
|
||||
if (!TEST_true(RAND_set_rand_method(&fake_rand)))
|
||||
@@ -170,7 +175,8 @@ static int test_sm2_crypt(const EC_GROUP *group,
|
||||
|
||||
start_fake_rand(k_hex);
|
||||
if (!TEST_true(sm2_encrypt(key, digest, (const uint8_t *)message, msg_len,
|
||||
ctext, &ctext_len))) {
|
||||
ctext, &ctext_len))
|
||||
|| !TEST_size_t_eq(fake_rand_bytes_offset, fake_rand_size)) {
|
||||
restore_rand();
|
||||
goto done;
|
||||
}
|
||||
@@ -222,7 +228,9 @@ static int sm2_crypt_test(void)
|
||||
EVP_sm3(),
|
||||
"1649AB77A00637BD5E2EFE283FBF353534AA7F7CB89463F208DDBC2920BB0DA0",
|
||||
"encryption standard",
|
||||
"004C62EEFD6ECFC2B95B92FD6C3D9575148AFA17425546D49018E5388D49DD7B4F",
|
||||
"004C62EEFD6ECFC2B95B92FD6C3D9575148AFA17425546D49018E5388D49DD7B4F"
|
||||
"0092e8ff62146873c258557548500ab2df2a365e0609ab67640a1f6d57d7b17820"
|
||||
"008349312695a3e1d2f46905f39a766487f2432e95d6be0cb009fe8c69fd8825a7",
|
||||
"307B0220245C26FB68B1DDDDB12C4B6BF9F2B6D5FE60A383B0D18D1C4144ABF1"
|
||||
"7F6252E7022076CB9264C2A7E88E52B19903FDC47378F605E36811F5C07423A2"
|
||||
"4B84400F01B804209C3D7360C30156FAB7C80A0276712DA9D8094A634B766D3A"
|
||||
@@ -235,7 +243,9 @@ static int sm2_crypt_test(void)
|
||||
EVP_sha256(),
|
||||
"1649AB77A00637BD5E2EFE283FBF353534AA7F7CB89463F208DDBC2920BB0DA0",
|
||||
"encryption standard",
|
||||
"004C62EEFD6ECFC2B95B92FD6C3D9575148AFA17425546D49018E5388D49DD7B4F",
|
||||
"004C62EEFD6ECFC2B95B92FD6C3D9575148AFA17425546D49018E5388D49DD7B4F"
|
||||
"003da18008784352192d70f22c26c243174a447ba272fec64163dd4742bae8bc98"
|
||||
"00df17605cf304e9dd1dfeb90c015e93b393a6f046792f790a6fa4228af67d9588",
|
||||
"307B0220245C26FB68B1DDDDB12C4B6BF9F2B6D5FE60A383B0D18D1C4144ABF17F"
|
||||
"6252E7022076CB9264C2A7E88E52B19903FDC47378F605E36811F5C07423A24B84"
|
||||
"400F01B80420BE89139D07853100EFA763F60CBE30099EA3DF7F8F364F9D10A5E9"
|
||||
@@ -285,10 +295,12 @@ static int test_sm2_sign(const EC_GROUP *group,
|
||||
|
||||
start_fake_rand(k_hex);
|
||||
sig = sm2_do_sign(key, EVP_sm3(), userid, (const uint8_t *)message, msg_len);
|
||||
restore_rand();
|
||||
|
||||
if (!TEST_ptr(sig))
|
||||
if (!TEST_ptr(sig)
|
||||
|| !TEST_size_t_eq(fake_rand_bytes_offset, fake_rand_size)) {
|
||||
restore_rand();
|
||||
goto done;
|
||||
}
|
||||
restore_rand();
|
||||
|
||||
ECDSA_SIG_get0(sig, &sig_r, &sig_s);
|
||||
|
||||
@@ -337,7 +349,8 @@ static int sm2_sig_test(void)
|
||||
"ALICE123@YAHOO.COM",
|
||||
"128B2FA8BD433C6C068C8D803DFF79792A519A55171B1B650C23661D15897263",
|
||||
"message digest",
|
||||
"006CB28D99385C175C94F94E934817663FC176D925DD72B727260DBAAE1FB2F96F",
|
||||
"006CB28D99385C175C94F94E934817663FC176D925DD72B727260DBAAE1FB2F96F"
|
||||
"007c47811054c6f99613a578eb8453706ccb96384fe7df5c171671e760bfa8be3a",
|
||||
"40F1EC59F793D9F49E09DCEF49130D4194F79FB1EED2CAA55BACDB49C4E755D1",
|
||||
"6FC6DAC32C5D5CF10C77DFB20F7C2EB667A457872FB09EC56327A67EC7DEEBE7")))
|
||||
goto done;
|
||||
|
||||
+2
-2
@@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
|
||||
* Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the OpenSSL licenses, (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
@@ -161,6 +161,6 @@ int setup_tests(void)
|
||||
return 0;
|
||||
}
|
||||
|
||||
ADD_ALL_TESTS(test_certs, n);
|
||||
ADD_ALL_TESTS(test_certs, (int)n);
|
||||
return 1;
|
||||
}
|
||||
+1
-1
@@ -1,5 +1,5 @@
|
||||
#! /usr/bin/env perl
|
||||
# Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
# Copyright 1995-2018 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
|
||||
|
||||
+2
-1
@@ -728,7 +728,7 @@ BIO_snprintf 726 1_1_0 EXIST::FUNCTION:
|
||||
EC_POINT_hex2point 727 1_1_0 EXIST::FUNCTION:EC
|
||||
X509v3_get_ext_by_critical 728 1_1_0 EXIST::FUNCTION:
|
||||
ENGINE_get_default_RSA 729 1_1_0 EXIST::FUNCTION:ENGINE
|
||||
DSA_sign_setup 730 1_1_0 EXIST::FUNCTION:DSA
|
||||
DSA_sign_setup 730 1_1_0 EXIST::FUNCTION:DEPRECATEDIN_1_2_0,DSA
|
||||
OPENSSL_sk_new_null 731 1_1_0 EXIST::FUNCTION:
|
||||
PEM_read_PKCS8 732 1_1_0 EXIST::FUNCTION:STDIO
|
||||
BN_mod_sqr 733 1_1_0 EXIST::FUNCTION:
|
||||
@@ -4567,3 +4567,4 @@ EVP_PKEY_get_raw_public_key 4518 1_1_1 EXIST::FUNCTION:
|
||||
EVP_PKEY_get_raw_private_key 4519 1_1_1 EXIST::FUNCTION:
|
||||
EVP_PKEY_asn1_set_get_priv_key 4520 1_1_1 EXIST::FUNCTION:
|
||||
EVP_PKEY_asn1_set_get_pub_key 4521 1_1_1 EXIST::FUNCTION:
|
||||
EVP_PKEY_set_alias_type 4522 1_1_1 EXIST::FUNCTION:
|
||||
Reference in New Issue
Block a user