kris/boringssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
fc674c82c3
boringssl/crypto/bn/internal.h

268 lines
11 KiB
C
Raw Normal View History

Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
/* Copyright (C) 1995-1997 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
/* ====================================================================
* Copyright (c) 1998-2006 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@openssl.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
/* ====================================================================
* Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
*
* Portions of the attached software ("Contribution") are developed by
* SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
*
* The Contribution is licensed pursuant to the Eric Young open source
* license provided above.
*
* The binary polynomial arithmetic software is originally written by
* Sheueling Chang Shantz and Douglas Stebila of Sun Microsystems
* Laboratories. */
#ifndef OPENSSL_HEADER_BN_INTERNAL_H
#define OPENSSL_HEADER_BN_INTERNAL_H
#include <openssl/base.h>
Enable MSVC 128-bit multiplication regardless of OPENSSL_NO_ASM. This allows much code to be subsequently simplified and removed. Change-Id: I0ac256957c6eae9f35a70508bd454cb44f3f8653 Reviewed-on: https://boringssl-review.googlesource.com/7042 Reviewed-by: David Benjamin <davidben@google.com>
2016-02-04 06:26:25 +00:00
#if defined(OPENSSL_X86_64) && defined(_MSC_VER)
Wrap MSVC-only warning pragmas in a macro. There's a __pragma expression which allows this. Android builds us Windows with MinGW for some reason, so we actually do have to tolerate non-MSVC-compatible Windows compilers. (Clang for Windows is much more sensible than MinGW and intentionally mimicks MSVC.) MinGW doesn't understand MSVC's pragmas and warns a lot. #pragma warning is safe to suppress, so wrap those to shush them. This also lets us do away with a few ifdefs. Change-Id: I1f5a8bec4940d4b2d947c4c1cc9341bc15ec4972 Reviewed-on: https://boringssl-review.googlesource.com/8236 Reviewed-by: Adam Langley <agl@google.com>
2016-06-09 21:48:33 +01:00
OPENSSL_MSVC_PRAGMA(warning(push, 3))
Switch crypto/bn back to _umul128 on Windows clang. Upstream (impressively quickly) fixed the missing intrinsic. Switch Windows clang back to building the same code as MSVC. Also include the intrin.h header rather than forward-declare the intrinsic. clang only works if the header is explicitly included. Chromium forcibly includes it to work around these kinds of issues, but we shouldn't rely on it. BUG=crbug.com/438382 Change-Id: I0ff6d48e1a3aa455cff99f8dc4c407e88b84d446 Reviewed-on: https://boringssl-review.googlesource.com/2461 Reviewed-by: Adam Langley <agl@google.com>
2014-12-03 22:57:04 +00:00
#include <intrin.h>
Wrap MSVC-only warning pragmas in a macro. There's a __pragma expression which allows this. Android builds us Windows with MinGW for some reason, so we actually do have to tolerate non-MSVC-compatible Windows compilers. (Clang for Windows is much more sensible than MinGW and intentionally mimicks MSVC.) MinGW doesn't understand MSVC's pragmas and warns a lot. #pragma warning is safe to suppress, so wrap those to shush them. This also lets us do away with a few ifdefs. Change-Id: I1f5a8bec4940d4b2d947c4c1cc9341bc15ec4972 Reviewed-on: https://boringssl-review.googlesource.com/8236 Reviewed-by: Adam Langley <agl@google.com>
2016-06-09 21:48:33 +01:00
OPENSSL_MSVC_PRAGMA(warning(pop))
Switch crypto/bn back to _umul128 on Windows clang. Upstream (impressively quickly) fixed the missing intrinsic. Switch Windows clang back to building the same code as MSVC. Also include the intrin.h header rather than forward-declare the intrinsic. clang only works if the header is explicitly included. Chromium forcibly includes it to work around these kinds of issues, but we shouldn't rely on it. BUG=crbug.com/438382 Change-Id: I0ff6d48e1a3aa455cff99f8dc4c407e88b84d446 Reviewed-on: https://boringssl-review.googlesource.com/2461 Reviewed-by: Adam Langley <agl@google.com>
2014-12-03 22:57:04 +00:00
#pragma intrinsic(__umulh, _umul128)
#endif
Define `int128_t` and `uint128_t` in one place. Change-Id: Ia93130aadf319eaba1b6f2ec2896a4c50d9e8ede Reviewed-on: https://boringssl-review.googlesource.com/6975 Reviewed-by: David Benjamin <davidben@google.com>
2016-01-27 01:16:37 +00:00
#include "../internal.h"
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#if defined(__cplusplus)
extern "C" {
#endif
Get overflow checks right in BN_bin2bn. BN_bin2bn takes a size_t as it should, but it passes that into bn_wexpand which takes unsigned. Switch bn_wexpand and bn_expand to take size_t before they check bounds against INT_MAX. BIGNUM itself still uses int everywhere and we may want to audit all the arithmetic at some point. Although I suspect having bn_expand require that the number of bits fit in an int is sufficient to make everything happy, unless we're doing interesting arithmetic on the number of bits somewhere. Change-Id: Id191a4a095adb7c938cde6f5a28bee56644720c6 Reviewed-on: https://boringssl-review.googlesource.com/5680 Reviewed-by: Adam Langley <agl@google.com>
2015-08-11 17:05:02 +01:00
/* bn_expand acts the same as |bn_wexpand|, but takes a number of bits rather
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
* than a number of words. */
Get overflow checks right in BN_bin2bn. BN_bin2bn takes a size_t as it should, but it passes that into bn_wexpand which takes unsigned. Switch bn_wexpand and bn_expand to take size_t before they check bounds against INT_MAX. BIGNUM itself still uses int everywhere and we may want to audit all the arithmetic at some point. Although I suspect having bn_expand require that the number of bits fit in an int is sufficient to make everything happy, unless we're doing interesting arithmetic on the number of bits somewhere. Change-Id: Id191a4a095adb7c938cde6f5a28bee56644720c6 Reviewed-on: https://boringssl-review.googlesource.com/5680 Reviewed-by: Adam Langley <agl@google.com>
2015-08-11 17:05:02 +01:00
BIGNUM *bn_expand(BIGNUM *bn, size_t bits);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#if defined(OPENSSL_64_BIT)
aarch64 support. This is an initial cut at aarch64 support. I have only qemu to test it however—hopefully hardware will be coming soon. This also affects 32-bit ARM in that aarch64 chips can run 32-bit code and we would like to be able to take advantage of the crypto operations even in 32-bit mode. AES and GHASH should Just Work in this case: the -armx.pl files can be built for either 32- or 64-bit mode based on the flavour argument given to the Perl script. SHA-1 and SHA-256 don't work like this however because they've never support for multiple implementations, thus BoringSSL built for 32-bit won't use the SHA instructions on an aarch64 chip. No dedicated ChaCha20 or Poly1305 support yet. Change-Id: Ib275bc4894a365c8ec7c42f4e91af6dba3bd686c Reviewed-on: https://boringssl-review.googlesource.com/2801 Reviewed-by: Adam Langley <agl@google.com>
2015-01-09 23:44:37 +00:00
#if !defined(_MSC_VER)
/* MSVC doesn't support two-word integers on 64-bit. */
Define `int128_t` and `uint128_t` in one place. Change-Id: Ia93130aadf319eaba1b6f2ec2896a4c50d9e8ede Reviewed-on: https://boringssl-review.googlesource.com/6975 Reviewed-by: David Benjamin <davidben@google.com>
2016-01-27 01:16:37 +00:00
#define BN_ULLONG uint128_t
aarch64 support. This is an initial cut at aarch64 support. I have only qemu to test it however—hopefully hardware will be coming soon. This also affects 32-bit ARM in that aarch64 chips can run 32-bit code and we would like to be able to take advantage of the crypto operations even in 32-bit mode. AES and GHASH should Just Work in this case: the -armx.pl files can be built for either 32- or 64-bit mode based on the flavour argument given to the Perl script. SHA-1 and SHA-256 don't work like this however because they've never support for multiple implementations, thus BoringSSL built for 32-bit won't use the SHA instructions on an aarch64 chip. No dedicated ChaCha20 or Poly1305 support yet. Change-Id: Ib275bc4894a365c8ec7c42f4e91af6dba3bd686c Reviewed-on: https://boringssl-review.googlesource.com/2801 Reviewed-by: Adam Langley <agl@google.com>
2015-01-09 23:44:37 +00:00
#endif
#define BN_BITS2 64
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#define BN_BYTES 8
#define BN_BITS4 32
Do away with BN_LLONG in favor of BN_ULLONG. BN_LLONG is only ever used in #ifdefs. The actual type is BN_ULLONG. Switch the ifdefs to check on BN_ULLONG and remove BN_LLONG. Also fix signedness of all the constants (potentially avoiding undefined behavior in some operations). Change-Id: I3e7739bbe14c50ea7db04fc507a034a8cb315a5f Reviewed-on: https://boringssl-review.googlesource.com/6518 Reviewed-by: Adam Langley <agl@google.com>
2015-11-18 20:57:00 +00:00
#define BN_MASK2 (0xffffffffffffffffUL)
#define BN_MASK2l (0xffffffffUL)
#define BN_MASK2h (0xffffffff00000000UL)
#define BN_MASK2h1 (0xffffffff80000000UL)
Calculate inverse in |BN_MONT_CTX_set| in constant time w.r.t. modulus. Simplify the calculation of the Montgomery constants in |BN_MONT_CTX_set|, making the inversion constant-time. It should also be faster by avoiding any use of the |BIGNUM| API in favor of using only 64-bit arithmetic. Now it's obvious how it works. /s Change-Id: I59a1e1c3631f426fbeabd0c752e0de44bcb5fd75 Reviewed-on: https://boringssl-review.googlesource.com/9031 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2016-07-30 03:19:46 +01:00
#define BN_MONT_CTX_N0_LIMBS 1
Do away with BN_LLONG in favor of BN_ULLONG. BN_LLONG is only ever used in #ifdefs. The actual type is BN_ULLONG. Switch the ifdefs to check on BN_ULLONG and remove BN_LLONG. Also fix signedness of all the constants (potentially avoiding undefined behavior in some operations). Change-Id: I3e7739bbe14c50ea7db04fc507a034a8cb315a5f Reviewed-on: https://boringssl-review.googlesource.com/6518 Reviewed-by: Adam Langley <agl@google.com>
2015-11-18 20:57:00 +00:00
#define BN_TBIT (0x8000000000000000UL)
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#define BN_DEC_CONV (10000000000000000000UL)
#define BN_DEC_NUM 19
More macro hygiene improvements. I missed these in the last round. Change-Id: I9b47216eef87c662728e454670e9e516de71ca21 Reviewed-on: https://boringssl-review.googlesource.com/11740 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2016-10-24 20:25:11 +01:00
#define TOBN(hi, lo) ((BN_ULONG)(hi) << 32 | (lo))
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#elif defined(OPENSSL_32_BIT)
aarch64 support. This is an initial cut at aarch64 support. I have only qemu to test it however—hopefully hardware will be coming soon. This also affects 32-bit ARM in that aarch64 chips can run 32-bit code and we would like to be able to take advantage of the crypto operations even in 32-bit mode. AES and GHASH should Just Work in this case: the -armx.pl files can be built for either 32- or 64-bit mode based on the flavour argument given to the Perl script. SHA-1 and SHA-256 don't work like this however because they've never support for multiple implementations, thus BoringSSL built for 32-bit won't use the SHA instructions on an aarch64 chip. No dedicated ChaCha20 or Poly1305 support yet. Change-Id: Ib275bc4894a365c8ec7c42f4e91af6dba3bd686c Reviewed-on: https://boringssl-review.googlesource.com/2801 Reviewed-by: Adam Langley <agl@google.com>
2015-01-09 23:44:37 +00:00
#define BN_ULLONG uint64_t
#define BN_BITS2 32
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#define BN_BYTES 4
#define BN_BITS4 16
Do away with BN_LLONG in favor of BN_ULLONG. BN_LLONG is only ever used in #ifdefs. The actual type is BN_ULLONG. Switch the ifdefs to check on BN_ULLONG and remove BN_LLONG. Also fix signedness of all the constants (potentially avoiding undefined behavior in some operations). Change-Id: I3e7739bbe14c50ea7db04fc507a034a8cb315a5f Reviewed-on: https://boringssl-review.googlesource.com/6518 Reviewed-by: Adam Langley <agl@google.com>
2015-11-18 20:57:00 +00:00
#define BN_MASK2 (0xffffffffUL)
#define BN_MASK2l (0xffffUL)
#define BN_MASK2h1 (0xffff8000UL)
#define BN_MASK2h (0xffff0000UL)
Calculate inverse in |BN_MONT_CTX_set| in constant time w.r.t. modulus. Simplify the calculation of the Montgomery constants in |BN_MONT_CTX_set|, making the inversion constant-time. It should also be faster by avoiding any use of the |BIGNUM| API in favor of using only 64-bit arithmetic. Now it's obvious how it works. /s Change-Id: I59a1e1c3631f426fbeabd0c752e0de44bcb5fd75 Reviewed-on: https://boringssl-review.googlesource.com/9031 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2016-07-30 03:19:46 +01:00
/* On some 32-bit platforms, Montgomery multiplication is done using 64-bit
* arithmetic with SIMD instructions. On such platforms, |BN_MONT_CTX::n0|
* needs to be two words long. Only certain 32-bit platforms actually make use
* of n0[1] and shorter R value would suffice for the others. However,
* currently only the assembly files know which is which. */
#define BN_MONT_CTX_N0_LIMBS 2
Do away with BN_LLONG in favor of BN_ULLONG. BN_LLONG is only ever used in #ifdefs. The actual type is BN_ULLONG. Switch the ifdefs to check on BN_ULLONG and remove BN_LLONG. Also fix signedness of all the constants (potentially avoiding undefined behavior in some operations). Change-Id: I3e7739bbe14c50ea7db04fc507a034a8cb315a5f Reviewed-on: https://boringssl-review.googlesource.com/6518 Reviewed-by: Adam Langley <agl@google.com>
2015-11-18 20:57:00 +00:00
#define BN_TBIT (0x80000000UL)
#define BN_DEC_CONV (1000000000UL)
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#define BN_DEC_NUM 9
More macro hygiene improvements. I missed these in the last round. Change-Id: I9b47216eef87c662728e454670e9e516de71ca21 Reviewed-on: https://boringssl-review.googlesource.com/11740 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2016-10-24 20:25:11 +01:00
#define TOBN(hi, lo) (lo), (hi)
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#else
#error "Must define either OPENSSL_32_BIT or OPENSSL_64_BIT"
#endif
Share common definitions of |TOBN| and |BIGNUM_STATIC|. Previously, both crypto/dh and crypto/ec defined |TOBN| macros that did the same thing, but which took their arguments in the opposite order. This change makes the code consistently use the same macro. It also makes |STATIC_BIGNUM| available for internal use outside of crypto/bn. Change-Id: Ide57f6a5b74ea95b3585724c7e1a630c82a864d9 Reviewed-on: https://boringssl-review.googlesource.com/6528 Reviewed-by: Adam Langley <agl@google.com>
2015-11-18 08:00:09 +00:00
Fix up macros. Macros need a healthy dose of parentheses to avoid expression-level misparses. Most of this comes from the clang-tidy CL here: https://android-review.googlesource.com/c/235696/ Also switch most of the macros to use do { ... } while (0) to avoid all the excessive comma operators and statement-level misparses. Change-Id: I4c2ee51e347d2aa8c74a2d82de63838b03bbb0f9 Reviewed-on: https://boringssl-review.googlesource.com/11660 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2016-10-18 18:05:01 +01:00
#define STATIC_BIGNUM(x) \
{ \
(BN_ULONG *)(x), sizeof(x) / sizeof(BN_ULONG), \
sizeof(x) / sizeof(BN_ULONG), 0, BN_FLG_STATIC_DATA \
Share common definitions of |TOBN| and |BIGNUM_STATIC|. Previously, both crypto/dh and crypto/ec defined |TOBN| macros that did the same thing, but which took their arguments in the opposite order. This change makes the code consistently use the same macro. It also makes |STATIC_BIGNUM| available for internal use outside of crypto/bn. Change-Id: Ide57f6a5b74ea95b3585724c7e1a630c82a864d9 Reviewed-on: https://boringssl-review.googlesource.com/6528 Reviewed-by: Adam Langley <agl@google.com>
2015-11-18 08:00:09 +00:00
}
Do away with BN_LLONG in favor of BN_ULLONG. BN_LLONG is only ever used in #ifdefs. The actual type is BN_ULLONG. Switch the ifdefs to check on BN_ULLONG and remove BN_LLONG. Also fix signedness of all the constants (potentially avoiding undefined behavior in some operations). Change-Id: I3e7739bbe14c50ea7db04fc507a034a8cb315a5f Reviewed-on: https://boringssl-review.googlesource.com/6518 Reviewed-by: Adam Langley <agl@google.com>
2015-11-18 20:57:00 +00:00
#if defined(BN_ULLONG)
aarch64 support. This is an initial cut at aarch64 support. I have only qemu to test it however—hopefully hardware will be coming soon. This also affects 32-bit ARM in that aarch64 chips can run 32-bit code and we would like to be able to take advantage of the crypto operations even in 32-bit mode. AES and GHASH should Just Work in this case: the -armx.pl files can be built for either 32- or 64-bit mode based on the flavour argument given to the Perl script. SHA-1 and SHA-256 don't work like this however because they've never support for multiple implementations, thus BoringSSL built for 32-bit won't use the SHA instructions on an aarch64 chip. No dedicated ChaCha20 or Poly1305 support yet. Change-Id: Ib275bc4894a365c8ec7c42f4e91af6dba3bd686c Reviewed-on: https://boringssl-review.googlesource.com/2801 Reviewed-by: Adam Langley <agl@google.com>
2015-01-09 23:44:37 +00:00
#define Lw(t) (((BN_ULONG)(t))&BN_MASK2)
#define Hw(t) (((BN_ULONG)((t)>>BN_BITS2))&BN_MASK2)
#endif
Unexport bn_correct_top and bn_wexpand. Thanks to Rob Sloan for clearing out Android's uses of these functions. I forgot we can hide these now. BUG=97 Change-Id: I9bc7bf5ca379d3345743151e606f3e911367b4ed Reviewed-on: https://boringssl-review.googlesource.com/15364 Commit-Queue: Steven Valdez <svaldez@google.com> Reviewed-by: Robert Sloan <varomodt@google.com> Reviewed-by: Steven Valdez <svaldez@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-04-21 16:20:25 +01:00
/* bn_correct_top decrements |bn->top| until |bn->d[top-1]| is non-zero or
* until |top| is zero. If |bn| is zero, |bn->neg| is set to zero. */
void bn_correct_top(BIGNUM *bn);
/* bn_wexpand ensures that |bn| has at least |words| works of space without
* altering its value. It returns |bn| on success or NULL on allocation
* failure. */
BIGNUM *bn_wexpand(BIGNUM *bn, size_t words);
Avoid potential uninitialized memory read in crypto/ec/p256-x86_64.c. If the function returns early due to an error, then the coordinates of the result will have their |top| value set to a value beyond what has actually been been written. Fix that, and make it easier to avoid such issues in the future by refactoring the code. As a bonus, avoid a false positive MSVC 64-bit opt build "potentially uninitialized value used" warning. Change-Id: I8c48deb63163a27f739c8797962414f8ca2588cd Reviewed-on: https://boringssl-review.googlesource.com/6579 Reviewed-by: David Benjamin <davidben@google.com>
2016-03-09 03:09:40 +00:00
/* bn_set_words sets |bn| to the value encoded in the |num| words in |words|,
* least significant word first. */
int bn_set_words(BIGNUM *bn, const BN_ULONG *words, size_t num);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
BN_ULONG bn_mul_add_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w);
BN_ULONG bn_mul_words(BN_ULONG *rp, const BN_ULONG *ap, int num, BN_ULONG w);
void bn_sqr_words(BN_ULONG *rp, const BN_ULONG *ap, int num);
BN_ULONG bn_add_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num);
BN_ULONG bn_sub_words(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,int num);
void bn_mul_comba4(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b);
void bn_mul_comba8(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b);
void bn_sqr_comba8(BN_ULONG *r, const BN_ULONG *a);
void bn_sqr_comba4(BN_ULONG *r, const BN_ULONG *a);
/* bn_cmp_words returns a value less than, equal to or greater than zero if
* the, length |n|, array |a| is less than, equal to or greater than |b|. */
int bn_cmp_words(const BN_ULONG *a, const BN_ULONG *b, int n);
/* bn_cmp_words returns a value less than, equal to or greater than zero if the
* array |a| is less than, equal to or greater than |b|. The arrays can be of
* different lengths: |cl| gives the minimum of the two lengths and |dl| gives
* the length of |a| minus the length of |b|. */
int bn_cmp_part_words(const BN_ULONG *a, const BN_ULONG *b, int cl, int dl);
int bn_mul_mont(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *bp,
const BN_ULONG *np, const BN_ULONG *n0, int num);
Calculate inverse in |BN_MONT_CTX_set| in constant time w.r.t. modulus. Simplify the calculation of the Montgomery constants in |BN_MONT_CTX_set|, making the inversion constant-time. It should also be faster by avoiding any use of the |BIGNUM| API in favor of using only 64-bit arithmetic. Now it's obvious how it works. /s Change-Id: I59a1e1c3631f426fbeabd0c752e0de44bcb5fd75 Reviewed-on: https://boringssl-review.googlesource.com/9031 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2016-07-30 03:19:46 +01:00
uint64_t bn_mont_n0(const BIGNUM *n);
Calculate Montgomery RR without division. Get one step closer to removing the dependency on |BN_div| from most programs. Also get one step closer to a constant-time implementation of |BN_MONT_CTX_set|; we now "just" need to create a constant-time variant of |BN_mod_lshift1_quick|. Note that this version might actually increase the side channel signal, since the variance in timing in |BN_div| is probably less than the variance from the many conditional reductions in the new method. On one Windows x64 machine, the speed of RSA verification using the new version is not too different from the speed of the old code. However, |BN_div| is generally slow on Windows x64 so I expect this isn't faster on all platforms. Regardless, we generally consider ECDSA/EdDSA signature verification performance to be adaquate and RSA signature verification is much, much faster even with this change. For RSA signing the performance is not a significant factor since performance-sensitive applications will cache the |RSA| structure and the |RSA| structure will cache the Montgomery contexts. Change-Id: Ib14f1a35c99b8da435e190342657f6a839381a1a Reviewed-on: https://boringssl-review.googlesource.com/10520 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2016-08-20 00:58:40 +01:00
int bn_mod_exp_base_2_vartime(BIGNUM *r, unsigned p, const BIGNUM *n);
Calculate inverse in |BN_MONT_CTX_set| in constant time w.r.t. modulus. Simplify the calculation of the Montgomery constants in |BN_MONT_CTX_set|, making the inversion constant-time. It should also be faster by avoiding any use of the |BIGNUM| API in favor of using only 64-bit arithmetic. Now it's obvious how it works. /s Change-Id: I59a1e1c3631f426fbeabd0c752e0de44bcb5fd75 Reviewed-on: https://boringssl-review.googlesource.com/9031 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2016-07-30 03:19:46 +01:00
Remove dead platform-specific code in |BN_div|. It is always the case that |BN_ULLONG| is defined or we're building for 64-bit MSVC. Lots of code is trying to handle impossible cases where neither of those is true. Change-Id: Ie337adda1dfb453843c6e0999807dfa1afb1ed89 Reviewed-on: https://boringssl-review.googlesource.com/7043 Reviewed-by: David Benjamin <davidben@google.com>
2016-02-04 07:12:08 +00:00
#if defined(OPENSSL_X86_64) && defined(_MSC_VER)
Remove dead non-|BN_ULLONG|, non-64-bit-MSVC code in crypto/bn. It is always the case that either |BN_ULLONG| is defined or |BN_UMULT_LOHI| is defined because |BN_ULLONG| is defined everywhere except 64-bit MSVC, and BN_UMULT_LOHI is defined for 64-bit MSVC. Change-Id: I85e5d621458562501af1af65d587c0b8d937ba3b Reviewed-on: https://boringssl-review.googlesource.com/7044 Reviewed-by: David Benjamin <davidben@google.com>
2016-02-04 07:12:37 +00:00
#define BN_UMULT_LOHI(low, high, a, b) ((low) = _umul128((a), (b), &(high)))
#endif
#if !defined(BN_ULLONG) && !defined(BN_UMULT_LOHI)
#error "Either BN_ULLONG or BN_UMULT_LOHI must be defined on every platform."
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#endif
Don't use BN_mod_inverse for inverses mod p in RSA keygen. Instead, use BN_mod_exp_mont_consttime of p - 2. This removes two more call sites sensitive to BN_FLG_CONSTTIME. We're down to just that last BN_mod_inverse modulo φ(n). (Sort of. It's actually not sensitive because even mod inverses always hit the other codepath. Perhaps we should just leave it alone.) Note this comes with a slight behavior change. The BN_MONT_CTXs are initialized a little earlier. If a caller calls RSA_generate_* and then reaches into the struct to scrap all the fields on it, they'll get confused. Before, they had to perform an operation on it to get confused. This is a completely ridiculous thing to do. Since we do this a lot, this introduces some convenience functions for doing the Fermat's Little Theorem mod inverse and fixes a leak in the DSA code should computing kinv hit a malloc error. BUG=125 Change-Id: Iafcae2fc6fd379d161f015c90ff7050e2282e905 Reviewed-on: https://boringssl-review.googlesource.com/12925 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2016-12-17 19:27:16 +00:00
/* bn_mod_inverse_prime sets |out| to the modular inverse of |a| modulo |p|,
* computed with Fermat's Little Theorem. It returns one on success and zero on
* error. If |mont_p| is NULL, one will be computed temporarily. */
int bn_mod_inverse_prime(BIGNUM *out, const BIGNUM *a, const BIGNUM *p,
BN_CTX *ctx, const BN_MONT_CTX *mont_p);
/* bn_mod_inverse_secret_prime behaves like |bn_mod_inverse_prime| but uses
* |BN_mod_exp_mont_consttime| instead of |BN_mod_exp_mont| in hopes of
* protecting the exponent. */
int bn_mod_inverse_secret_prime(BIGNUM *out, const BIGNUM *a, const BIGNUM *p,
BN_CTX *ctx, const BN_MONT_CTX *mont_p);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#if defined(__cplusplus)
} /* extern C */
#endif
#endif /* OPENSSL_HEADER_BN_INTERNAL_H */
Reference in New Issue Copy Permalink