Skip to content

Commit ce66e6d

Browse files
VeronicaGuptaVeronicaGupta
committed
chore: Modify points
1 parent c0c4537 commit ce66e6d

File tree

6 files changed

+74
-125
lines changed

6 files changed

+74
-125
lines changed

‎apps/starknet_app/starknet_crypto.c‎

Lines changed: 55 additions & 97 deletions
Original file line numberDiff line numberDiff line change
@@ -85,76 +85,29 @@
8585
/*****************************************************************************
8686
* GLOBAL VARIABLES
8787
*****************************************************************************/
88-
stark_curve stark256 = {
89-
.prime = /* .prime */ {/*.val =*/{0x3ffffc2f,
90-
0x3ffffffb,
91-
0x3fffffff,
92-
0x3fffffff,
93-
0x3fffffff,
94-
0x3fffffff,
95-
0x3fffffff,
96-
0x3fffffff,
97-
0xffff}},
98-
99-
// /* G */
100-
// {/*.x =*/{/*.val =*/{0x16f81798,
101-
// 0x27ca056c,
102-
// 0x1ce28d95,
103-
// 0x26ff36cb,
104-
// 0x70b0702,
105-
// 0x18a573a,
106-
// 0xbbac55a,
107-
// 0x199fbe77,
108-
// 0x79be}},
109-
// /*.y =*/{/*.val =*/{0x3b10d4b8,
110-
// 0x311f423f,
111-
// 0x28554199,
112-
// 0x5ed1229,
113-
// 0x1108a8fd,
114-
// 0x13eff038,
115-
// 0x3c4655da,
116-
// 0x369dc9a8,
117-
// 0x483a}}},
118-
119-
// /* order */
120-
// {/*.val =*/{0x10364141,
121-
// 0x3f497a33,
122-
// 0x348a03bb,
123-
// 0x2bb739ab,
124-
// 0x3ffffeba,
125-
// 0x3fffffff,
126-
// 0x3fffffff,
127-
// 0x3fffffff,
128-
// 0xffff}},
129-
130-
/* order_half */
131-
.order_half = {/*.val =*/{0x281b20a0,
132-
0x3fa4bd19,
133-
0x3a4501dd,
134-
0x15db9cd5,
135-
0x3fffff5d,
136-
0x3fffffff,
137-
0x3fffffff,
138-
0x3fffffff,
139-
0x7fff}},
140-
141-
// /* a */
142-
// {},
143-
144-
// /* b */ {/*.val =*/{7}}
145-
};
146-
147-
stark_pedersen pedersen;
88+
const stark_curve *starkCurve;
89+
const stark_pedersen *starkPts;
14890

14991
/*****************************************************************************
15092
* STATIC FUNCTIONS
15193
*****************************************************************************/
94+
static void stark_curve_init();
95+
static void stark_pedersen_init();
96+
static void print_stark_curve();
97+
static void print_stark_perdersen();
15298

15399
/*****************************************************************************
154100
* GLOBAL FUNCTIONS
155101
*****************************************************************************/
156-
void starknet_curve_init() {
157-
char str[65] = "";
102+
103+
void starknet_init() {
104+
stark_curve_init();
105+
stark_pedersen_init();
106+
}
107+
108+
static void stark_curve_init() {
109+
stark_curve stark256;
110+
char str[STARK_BN_LEN] = {0};
158111

159112
/* stark_curve_params ref:
160113
https://github.com/xJonathanLEI/starknet-rs/blob/f31e426a65225b9830bbf3c148f7ea05bf9dc257/starknet-curve/src/curve_params.rs
@@ -167,23 +120,21 @@ void starknet_curve_init() {
167120
*/
168121

169122
// Prime
170-
// bignum_from_int(
171-
// &stark256.prime,
172-
// "",
173-
// STARK_BN_LEN);
174-
175-
// bignum_to_string()
123+
bignum_from_string(
124+
&stark256.prime,
125+
"0800000000000011000000000000000000000000000000000000000000000001",
126+
STARK_BN_LEN);
176127

177128
// Generator_point x
178129
bignum_from_string(
179130
&stark256.G.x,
180-
"01ef15c18599971b7beced415a40f0c7deacfd9b0d1819e03d723d8bc943cfca",
131+
"01EF15C18599971B7BECED415A40F0C7DEACFD9B0D1819E03D723D8BC943CFCA",
181132
STARK_BN_LEN);
182133

183134
// Generator_point y
184135
bignum_from_string(
185136
&stark256.G.y,
186-
"005668060aa49730b7be4801df46ec62de53ecd11abe43a32873000c36e8dc1f",
137+
"005668060AA49730B7BE4801DF46EC62DE53ECD11ABE43A32873000C36E8DC1F",
187138
STARK_BN_LEN);
188139

189140
// Order
@@ -193,10 +144,10 @@ void starknet_curve_init() {
193144
STARK_BN_LEN);
194145

195146
// Order half
196-
// bignum_from_string(
197-
// &stark256.order_half,
198-
// "",
199-
// STARK_BN_LEN);
147+
bignum_from_string(
148+
&stark256.order_half,
149+
"06F21413EFBE40DE150E596D72F7A8C5609AD26C15C915C1F4CDFCB99CEE9E89",
150+
STARK_BN_LEN);
200151

201152
// Alpha
202153
bignum_from_string(
@@ -211,11 +162,15 @@ void starknet_curve_init() {
211162
STARK_BN_LEN);
212163

213164
print_stark_curve();
165+
166+
starkCurve = &stark256;
214167
}
215168

216-
void starknet_pedersen_init() {
169+
static void stark_pedersen_init() {
217170
// Ref: https://docs.starkware.co/starkex/crypto/pedersen-hash-function.html
218-
char str[65] = "";
171+
172+
stark_pedersen pedersen;
173+
char str[STARK_BN_LEN] = {0};
219174

220175
// Shift_point
221176
// x
@@ -278,41 +233,44 @@ void starknet_pedersen_init() {
278233
STARK_BN_LEN);
279234

280235
print_stark_perdersen();
236+
237+
starkPts = &pedersen;
281238
}
282239

283-
void print_stark_curve() {
240+
static void print_stark_curve() {
284241
char str[STARK_BN_LEN];
285242

286-
bignum_to_string(&stark256.prime, str, STARK_BN_LEN);
287-
print_hex_array("\nPrime", str, STARK_BN_LEN / 2);
243+
bignum_to_string(&starkCurve->prime, str, STARK_BN_LEN);
244+
printf("\nPrime: %s", str);
245+
246+
bignum_to_string(&starkCurve->G.x, str, STARK_BN_LEN);
247+
printf("\nG x: %s", str);
288248

289-
bignum_to_string(&stark256.G.x, str, STARK_BN_LEN);
290-
print_hex_array("G (Generator Point) x", str, STARK_BN_LEN / 2);
291-
bignum_to_string(&stark256.G.y, str, STARK_BN_LEN);
292-
print_hex_array("G (Generator Point) y", str, STARK_BN_LEN / 2);
249+
bignum_to_string(&starkCurve->G.y, str, STARK_BN_LEN);
250+
printf("\nG y: %s", str);
293251

294-
bignum_to_string(&stark256.order, str, STARK_BN_LEN);
295-
print_hex_array("Order", str, STARK_BN_LEN / 2);
252+
bignum_to_string(&starkCurve->order, str, STARK_BN_LEN);
253+
printf("\nOrder: %s", str);
296254

297-
bignum_to_string(&stark256.order_half, str, STARK_BN_LEN);
298-
print_hex_array("Order half", str, STARK_BN_LEN / 2);
255+
bignum_to_string(&starkCurve->order_half, str, STARK_BN_LEN);
256+
printf("\nOrder half: %s", str);
299257

300-
bignum_to_string(&stark256.a, str, STARK_BN_LEN);
301-
print_hex_array("Alpha", str, STARK_BN_LEN / 2);
258+
bignum_to_string(&starkCurve->a, str, STARK_BN_LEN);
259+
printf("\nAlpha: %s", str);
302260

303-
bignum_to_string(&stark256.b, str, STARK_BN_LEN);
304-
print_hex_array("Beta", str, STARK_BN_LEN / 2);
261+
bignum_to_string(&starkCurve->b, str, STARK_BN_LEN);
262+
printf("\nBeta: %s", str);
305263
}
306264

307-
void print_stark_perdersen() {
265+
static void print_stark_perdersen() {
308266
char str[STARK_BN_LEN];
309267

310268
for (int i = 0; i < 5; i++) {
311-
bignum_to_string(&pedersen.P[i].x, str, STARK_BN_LEN);
312-
print_hex_array("P (Pedersen Point) x", str, STARK_BN_LEN / 2);
269+
bignum_to_string(&starkPts->P[i].x, str, STARK_BN_LEN);
270+
printf("P%d (Pedersen Point) x", i, str);
313271

314-
bignum_to_string(&pedersen.P[i].y, str, STARK_BN_LEN);
315-
print_hex_array("P (Pedersen Point) y", str, STARK_BN_LEN / 2);
272+
bignum_to_string(&starkPts->P[i].y, str, STARK_BN_LEN);
273+
printf("P%d (Pedersen Point) y", i, str);
316274
}
317275
}
318276

@@ -404,7 +362,7 @@ int stark_point_is_negative_of(const stark_point *p, const stark_point *q) {
404362
void private_to_public_key(const uint8_t *private, uint8_t *public_65) {
405363
stark_point R = {0}, temp = {0};
406364

407-
const stark_curve *curve = &stark256;
365+
const stark_curve *curve = starkCurve;
408366
stark_point_set_infinity(&R);
409367
stark_point_copy(&curve->G, &temp);
410368

‎apps/starknet_app/starknet_crypto.h‎

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -45,9 +45,8 @@ typedef struct {
4545
/*****************************************************************************
4646
* EXPORTED VARIABLES
4747
*****************************************************************************/
48-
49-
extern stark_curve stark256;
50-
extern stark_pedersen pedersen;
48+
extern const stark_curve *starkCurve;
49+
extern const stark_pedersen *starkPts;
5150

5251
/*****************************************************************************
5352
* GLOBAL FUNCTION PROTOTYPES
@@ -66,7 +65,6 @@ void stark_point_set_infinity(stark_point *p);
6665
int stark_point_is_infinity(const stark_point *p);
6766
int stark_point_is_equal(const stark_point *p, const stark_point *q);
6867

69-
void starknet_curve_init();
70-
void starknet_pedersen_init();
68+
void starknet_init();
7169

7270
#endif // STARKNET_CRYPTO_H

‎apps/starknet_app/starknet_pedersen.c‎

Lines changed: 13 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -101,8 +101,6 @@ bool pederson_hash(uint8_t *x, uint8_t *y, uint8_t size, uint8_t *hash) {
101101
ASSERT(NULL != y);
102102
ASSERT(0 < size);
103103

104-
const stark_curve *curve = &stark256;
105-
106104
// Convert to bn
107105
char hex[100] = {0};
108106
struct bn a, b, result;
@@ -114,19 +112,19 @@ bool pederson_hash(uint8_t *x, uint8_t *y, uint8_t size, uint8_t *hash) {
114112

115113
// Get shift point
116114
stark_point HASH_SHIFT_POINT, P_1, P_2, P_3, P_4;
117-
stark_point_copy(&HASH_SHIFT_POINT, &pedersen.P[0]);
118-
stark_point_copy(&P_1, &pedersen.P[1]);
119-
stark_point_copy(&P_2, &pedersen.P[2]);
120-
stark_point_copy(&P_3, &pedersen.P[3]);
121-
stark_point_copy(&P_4, &pedersen.P[4]);
115+
stark_point_copy(&HASH_SHIFT_POINT, &starkPts->P[0]);
116+
stark_point_copy(&P_1, &starkPts->P[1]);
117+
stark_point_copy(&P_2, &starkPts->P[2]);
118+
stark_point_copy(&P_3, &starkPts->P[3]);
119+
stark_point_copy(&P_4, &starkPts->P[4]);
122120

123121
// Compute the hash using the Starkware Pedersen hash definition
124122
stark_point x_part, y_part, hash_point;
125123
process_single_element(x, &P_1, &P_2, &x_part);
126124
process_single_element(y, &P_3, &P_4, &y_part);
127125

128-
stark_point_add(curve, &HASH_SHIFT_POINT, &x_part, &hash_point);
129-
stark_point_add(curve, &hash_point, &y_part, &hash_point);
126+
stark_point_add(starkCurve, &HASH_SHIFT_POINT, &x_part, &hash_point);
127+
stark_point_add(starkCurve, &hash_point, &y_part, &hash_point);
130128

131129
memzero(hash, 32);
132130
memzero(hex, 100);
@@ -136,25 +134,24 @@ bool pederson_hash(uint8_t *x, uint8_t *y, uint8_t size, uint8_t *hash) {
136134
return true;
137135
}
138136

139-
void process_single_element(const stark_curve *curve,
140-
struct bn *element,
137+
void process_single_element(struct bn *element,
141138
stark_point *p1,
142139
stark_point *p2,
143140
stark_point *result) {
144-
ASSERT(bignum_cmp(element, &stark256.prime) == SMALLER);
141+
ASSERT(bignum_cmp(element, &starkCurve->prime) == SMALLER);
145142

146143
struct bn low_part, high_nibble;
147144
bignum_init(&low_part);
148145
bignum_init(&high_nibble);
149146

150147
// Extract the low 248 bits and high bits from the element
151-
bignum_and(&low_part, element, LOW_PART_MASK);
148+
bignum_and(&low_part, element, element);
152149
bignum_rshift(&high_nibble, element, LOW_PART_BITS);
153150

154151
stark_point res1, res2;
155-
// point_multiply(stark256, p1, &low_part, &res1); // low_part * p1
156-
// point_multiply(stark256, p2, &high_nibble, &res2); // high_nibble * p2
157-
stark_point_add(curve, &res1, &res2, result); // Combine results
152+
point_multiply(starkCurve, p1, &low_part, &res1); // low_part * p1
153+
point_multiply(starkCurve, p2, &high_nibble, &res2); // high_nibble * p2
154+
stark_point_add(starkCurve, &res1, &res2, result); // Combine results
158155

159156
stark_point_copy(&res2, result);
160157
}

‎apps/starknet_app/starknet_serialise.c‎

Whitespace-only changes.

‎tests/apps/starknet_app/starknet_helper_tests.c‎

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -72,15 +72,14 @@
7272

7373
TEST_GROUP(starknet_helper_test);
7474

75-
extern starknet_txn_context_t *txn_context;
76-
7775
/**
7876
* @brief Test setup for usb event consumer tests.
7977
* @details The function populates data in local buffer of USB communication
8078
* module so that the event getter has an event ready for dispatch for
8179
* performing tests. buffer of packet(s) of data.
8280
*/
8381
TEST_SETUP(starknet_helper_test) {
82+
starknet_init();
8483
}
8584

8685
/**
@@ -116,9 +115,6 @@ TEST(starknet_helper_test, starknet_pedersen_hash) {
116115
64,
117116
expected_hash);
118117

119-
starknet_curve_init();
120-
starknet_pedersen_init();
121-
122118
TEST_ASSERT_TRUE(pederson_hash(x, y, 32, hash));
123119

124120
TEST_ASSERT_EQUAL_UINT8_ARRAY(expected_hash, hash, 32);

‎tests/apps/starknet_app/starknet_txn_tests.c‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -62,6 +62,7 @@
6262
#include "pb_encode.h"
6363
#include "starknet_api.h"
6464
#include "starknet_context.h"
65+
#include "starknet_crypto.h"
6566
#include "starknet_main.h"
6667
#include "starknet_priv.h"
6768
#include "unity_fixture.h"
@@ -79,6 +80,7 @@ extern starknet_txn_context_t *txn_context;
7980
* performing tests. buffer of packet(s) of data.
8081
*/
8182
TEST_SETUP(starknet_txn_test) {
83+
starknet_init();
8284
}
8385

8486
/**
@@ -126,8 +128,6 @@ TEST(starknet_txn_test, starknet_get_public_key_action) {
126128
128,
127129
seed);
128130

129-
starknet_curve_init();
130-
131131
TEST_ASSERT_TRUE(fill_starknet_public_keys(
132132
query.get_public_keys.initiate.derivation_paths,
133133
seed,

0 commit comments

Comments
 (0)