Dash Core Source Documentation (0.16.0.1)

Find detailed information regarding the Dash Core source code.

scalar_low_impl.h
Go to the documentation of this file.
1 /**********************************************************************
2  * Copyright (c) 2015 Andrew Poelstra *
3  * Distributed under the MIT software license, see the accompanying *
4  * file COPYING or http://www.opensource.org/licenses/mit-license.php.*
5  **********************************************************************/
6 
7 #ifndef SECP256K1_SCALAR_REPR_IMPL_H
8 #define SECP256K1_SCALAR_REPR_IMPL_H
9 
10 #include "scalar.h"
11 
12 #include <string.h>
13 
15  return !(*a & 1);
16 }
17 
19 SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v) { *r = v; }
20 
21 SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
22  if (offset < 32)
23  return ((*a >> offset) & ((((uint32_t)1) << count) - 1));
24  else
25  return 0;
26 }
27 
28 SECP256K1_INLINE static unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count) {
29  return secp256k1_scalar_get_bits(a, offset, count);
30 }
31 
33 
35  *r = (*a + *b) % EXHAUSTIVE_TEST_ORDER;
36  return *r < *b;
37 }
38 
39 static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag) {
40  if (flag && bit < 32)
41  *r += (1 << bit);
42 #ifdef VERIFY
44 #endif
45 }
46 
47 static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow) {
48  const int base = 0x100 % EXHAUSTIVE_TEST_ORDER;
49  int i;
50  *r = 0;
51  for (i = 0; i < 32; i++) {
52  *r = ((*r * base) + b32[i]) % EXHAUSTIVE_TEST_ORDER;
53  }
54  /* just deny overflow, it basically always happens */
55  if (overflow) *overflow = 0;
56 }
57 
58 static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar* a) {
59  memset(bin, 0, 32);
60  bin[28] = *a >> 24; bin[29] = *a >> 16; bin[30] = *a >> 8; bin[31] = *a;
61 }
62 
64  return *a == 0;
65 }
66 
68  if (*a == 0) {
69  *r = 0;
70  } else {
71  *r = EXHAUSTIVE_TEST_ORDER - *a;
72  }
73 }
74 
76  return *a == 1;
77 }
78 
80  return *a > EXHAUSTIVE_TEST_ORDER / 2;
81 }
82 
84  if (flag) secp256k1_scalar_negate(r, r);
85  return flag ? -1 : 1;
86 }
87 
89  *r = (*a * *b) % EXHAUSTIVE_TEST_ORDER;
90 }
91 
93  int ret;
94  VERIFY_CHECK(n > 0);
95  VERIFY_CHECK(n < 16);
96  ret = *r & ((1 << n) - 1);
97  *r >>= n;
98  return ret;
99 }
100 
102  *r = (*a * *a) % EXHAUSTIVE_TEST_ORDER;
103 }
104 
106  *r1 = *a;
107  *r2 = 0;
108 }
109 
111  return *a == *b;
112 }
113 
114 #endif /* SECP256K1_SCALAR_REPR_IMPL_H */
#define VERIFY_CHECK(cond)
Definition: util.h:67
static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned char *b32, int *overflow)
static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n)
static void secp256k1_scalar_sqr(secp256k1_scalar *r, const secp256k1_scalar *a)
static SECP256K1_INLINE void secp256k1_scalar_set_int(secp256k1_scalar *r, unsigned int v)
static SECP256K1_INLINE int secp256k1_scalar_eq(const secp256k1_scalar *a, const secp256k1_scalar *b)
static SECP256K1_INLINE int secp256k1_scalar_is_even(const secp256k1_scalar *a)
static SECP256K1_INLINE unsigned int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int offset, unsigned int count)
static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int bit, int flag)
#define SECP256K1_INLINE
Definition: secp256k1.h:123
static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b)
static SECP256K1_INLINE unsigned int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned int offset, unsigned int count)
static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_scalar *a, const secp256k1_scalar *b)
A scalar modulo the group order of the secp256k1 curve.
Definition: scalar_4x64.h:13
static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1_scalar *a)
static SECP256K1_INLINE int secp256k1_scalar_is_one(const secp256k1_scalar *a)
static SECP256K1_INLINE int secp256k1_scalar_is_zero(const secp256k1_scalar *a)
static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_scalar *r2, const secp256k1_scalar *a)
static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1_scalar *a)
#define EXHAUSTIVE_TEST_ORDER
static SECP256K1_INLINE void secp256k1_scalar_clear(secp256k1_scalar *r)
static int count
Definition: tests.c:45
static SECP256K1_INLINE int secp256k1_scalar_check_overflow(const secp256k1_scalar *a)
static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag)
static int secp256k1_scalar_is_high(const secp256k1_scalar *a)
Released under the MIT license