void Parallel_MAC_Check<T>::POpen_Begin(vector<T>& values,
const vector<Share<T> >& S, const Player& P)
{
values.size();
this->AddToMacs(S);
int my_relative_num = positive_modulo(P.my_num() - send_base_player, P.num_players());
int sum_players = (P.num_players() - 2 + this->opening_sum) / this->opening_sum;
int receiver = positive_modulo(send_base_player + my_relative_num % sum_players, P.num_players());
// use queue rather sending to myself
if (receiver == P.my_num())
{
for (unsigned int i = 0; i < S.size(); i++)
values[i] = S[i].get_share();
summers.front()->share_queue.push(values);
}
else
{
this->os.reset_write_head();
for (unsigned int i=0; i<S.size(); i++)
S[i].get_share().pack(this->os);
this->timers[SEND].start();
send_player.send_to(receiver,this->os,true);
this->timers[SEND].stop();
}
for (unsigned int i = 0; i < summers.size(); i++)
summers[i]->input_queue.push(S.size());
this->values_opened += S.size();
send_base_player = (send_base_player + 1) % send_player.num_players();
}
long long mode(long long n, long long p, long long r)
{
long long i;
long long a1 = positive_modulo(n, r);
long long q = 1;
for (i = 1; i <= p; i++) {
q *= a1;
q = positive_modulo(q, r);
}
return q;
}
long long gcd(long long a, long long b)
{
if (b == 0)
return a;
else
return gcd(b, positive_modulo(a, b));
}
void game_update(Game* game, int acce_x)
{
int screenSpeed = -(game->score / 1000);
// save previous screen position
game->prevScreenPos = game->screenPos;
game->screenPos = positive_modulo((game->screenPos + screenSpeed - 1), SCREEN_SCROLLING_HEIGHT);
game->player->x += (acce_x / 10) - 1; // calibration
game->player->y = SCREEN_FIXED_TOP_HEIGHT + positive_modulo(game->screenPos + 160, SCREEN_SCROLLING_HEIGHT);
game->score += -screenSpeed + 1;
// check for collision
if (game_isThereCollision(game)) {
game->over = 1;
}
}
void game_drawNewLines(Game* game)
{
unsigned char middle, x1, x2, y, real_y;
short i;
float val = (float)game->score / 30.0;
unsigned short numlines = positive_modulo(game->prevScreenPos - game->screenPos + 1, SCREEN_SCROLLING_HEIGHT);
middle = sin(val / 5.0) * HX8340B_LCDWIDTH / 5 + HX8340B_LCDWIDTH / 2;
x1 = middle - (1.5 + sin(val)) * 20.0;
x2 = middle + (1.5 + cos(val * 1.2)) * 20.0;
for (i = 0; i <= numlines - 1; i++) {
y = positive_modulo(game->screenPos - i, SCREEN_SCROLLING_HEIGHT);
game->lines[y].x1 = x1;
game->lines[y].x2 = x2;
real_y = SCREEN_FIXED_TOP_HEIGHT + y;
screen_drawGameLine(real_y, x1, x2, COLOR_BLACK, COLOR_WHITE);
}
}
int main() {
/** Fm, where modulo = m */
mpz_t a, b, k, r, modulo;
int i = 0; // loop variable
Point p, next_p;
p = init_point(p);
mpz_init(a);
mpz_init(b);
mpz_init(k);
mpz_init(r); // order
mpz_init(modulo);
/** Initialize parameters of ECC (F2p) */
mpz_set_str(a, a_v, 10);
mpz_set_str(b, b_v, 16);
mpz_set_str(modulo, p_v, 10);
mpz_set_str(r, r_v, 10);
mpz_set_str(p.x, gx_v, 16);
mpz_set_str(p.y, gy_v, 16);
mpz_t zero_value, k2;
mpz_init(zero_value);
mpz_init(k2);
RDTSC_START(t1);
sleep(1); // sleep for 1 second
RDTSC_STOP(t2);
uint64_t one_second = t2 - t1 - rdtscp_cycle;
printf("Approximate number of cycles in 1 second: %lld\n\n", one_second);
uint64_t one_us = one_second / 1e6;
while (mpz_cmp(k, zero_value) == 0) {
get_random(k, 32); // generate random test (256 bits)
positive_modulo(k, k, modulo);
}
printf("Random k (in Binary): ");
mpz_out_str(stdout, 2, k);
printf("\n");
while (mpz_cmp(k2, zero_value) == 0) {
get_random(k2, 32); // generate random test (256 bits)
positive_modulo(k2, k2, modulo);
}
printf("Random k2 (in Binary): ");
mpz_out_str(stdout, 2, k2);
printf("\n");
/** Compare ADDITION, SHIFTING, MULTIPLICATION, and INVERSION */
if (TEST_MODULAR_OPERATION) {
max_iteration = 10000;
/** Addition */
i = 0;
uint64_t total = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
mpz_add(k, k, k2);
positive_modulo(k, k, modulo);
RDTSC_STOP(t2); // stop operation
total += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[ADDITION]--\n");
print_result(total, one_us);
/** Shifting */
i = 0;
uint64_t total2 = 0;
mpz_t two;
mpz_init(two);
mpz_set_si(two, 2);
while (i < max_iteration) {
RDTSC_START(t1); // start operation
mpz_mul_2exp(k, k, 1); // left shift
positive_modulo(k, k, modulo);
RDTSC_STOP(t2); // stop operation
total2 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[SHIFTING 2 * k]--\n");
print_result(total2, one_us);
/** Multiplication */
i = 0;
uint64_t total3 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
mpz_mul(k, k, k2);
positive_modulo(k, k, modulo);
RDTSC_STOP(t2); // stop operation
total3 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[MULTIPLICATION k * k2]--\n");
print_result(total3, one_us);
/** Inversion */
i = 0;
uint64_t total4 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
mpz_invert(k, k, modulo);
RDTSC_STOP(t2); // stop operation
total4 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[INVERSION]--\n");
print_result(total4, one_us);
}
/** -------------------------------------------------------------------------*/
// Convert Affine coordinate to Jacobian coordinate
J_Point j_p, j_next_p;
j_next_p = init_j_point(j_next_p);
j_p = affine_to_jacobian(p); // Generator point
if (TEST_SCALAR_OPERATION) {
max_iteration = 100;
Point p1, p2, p3;
J_Point j_p1, j_p2, j_p3;
/** Point preparation */
p1 = init_point(p1); p2 = init_point(p2);
j_p1 = init_j_point(j_p1); j_p2 = init_j_point(j_p2);
j_p1 = jacobian_affine_sliding_NAF(j_p, p, a, k, modulo, 4);
j_p2 = jacobian_affine_sliding_NAF(j_p, p, a, k2, modulo, 4);
p1 = jacobian_to_affine(j_p1, modulo);
p2 = jacobian_to_affine(j_p2, modulo);
/** Affine addition */
i = 0;
uint64_t total = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
p3 = affine_curve_addition(p1, p2, a, modulo);
RDTSC_STOP(t2); // stop operation
total += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[ADDITION in AFFINE]--\n");
print_result(total, one_us);
/** Affine doubling */
i = 0;
uint64_t total2 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
p3 = affine_curve_doubling(p1, a, modulo);
RDTSC_STOP(t2); // stop operation
total2 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[DOUBLING in AFFINE]--\n");
print_result(total2, one_us);
/** Jacobian addition */
i = 0;
uint64_t total3 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_p3 = jacobian_curve_addition(j_p1, j_p2, a, modulo);
RDTSC_STOP(t2); // stop operation
total3 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[ADDITION in JACOBIAN]--\n");
print_result(total3, one_us);
/** Jacobian doubling */
i = 0;
uint64_t total4 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_p3 = jacobian_curve_doubling(j_p1, a, modulo);
RDTSC_STOP(t2); // stop operation
total4 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[DOUBLING in JACOBIAN]--\n");
print_result(total4, one_us);
/** Affine-Jacobian addition */
i = 0;
uint64_t total5 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_p3 = jacobian_affine_curve_addition(j_p1, p2, a, modulo);
RDTSC_STOP(t2); // stop operation
total5 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[ADDITION in JACOBIAN-AFFINE]--\n");
print_result(total5, one_us);
}
/** -------------------------------------------------------------------------*/
if (TEST_SCALAR_ALGORITHM) {
max_iteration = 100;
/** Test Left-to-right binary algorithm */
i = 0;
uint64_t total = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
next_p = affine_left_to_right_binary(p, a, k, modulo); // Q = [k]P
// gmp_printf("%Zd %Zd\n", next_p.x, next_p.y);
RDTSC_STOP(t2); // stop operation
total += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[AFFINE] Left to right binary algorithm--\n");
print_result(total, one_us);
i = 0;
uint64_t total2 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_next_p = jacobian_left_to_right_binary(j_p, a, k, modulo); // Q = [k]P
// gmp_printf("%Zd %Zd\n", j_next_p.X, j_next_p.Y);
next_p = jacobian_to_affine(j_next_p, modulo);
// gmp_printf("%Zd %Zd\n", next_p.x, next_p.y);
RDTSC_STOP(t2); // stop operation
total2 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[JACOBIAN] Left to right binary algorithm--\n");
print_result(total2, one_us);
i = 0;
uint64_t total3 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_next_p = jacobian_affine_left_to_right_binary(j_p, p, a, k, modulo); // Q = [k]P
// gmp_printf("%Zd %Zd\n", j_next_p.X, j_next_p.Y);
next_p = jacobian_to_affine(j_next_p, modulo);
// gmp_printf("%Zd %Zd\n", next_p.x, next_p.y);
RDTSC_STOP(t2); // stop operation
total3 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[JACOBIAN-AFFINE] Left to right binary algorithm--\n");
print_result(total3, one_us);
int w = 4; // windows size
i = 0;
uint64_t total4 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_next_p = jacobian_affine_sliding_NAF(j_p, p, a, k, modulo, w); // Q = [k]P
// gmp_printf("%Zd %Zd\n", j_next_p.X, j_next_p.Y);
next_p = jacobian_to_affine(j_next_p, modulo);
// gmp_printf("%Zd %Zd\n", next_p.x, next_p.y);
RDTSC_STOP(t2); // stop operation
total4 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[JACOBIAN-AFFINE] Sliding NAF Left to right binary algorithm (w = 4)--\n");
print_result(total4, one_us);
w = 5; // windows size
i = 0;
uint64_t total5 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_next_p = jacobian_affine_sliding_NAF(j_p, p, a, k, modulo, w); // Q = [k]P
// gmp_printf("%Zd %Zd\n", j_next_p.X, j_next_p.Y);
next_p = jacobian_to_affine(j_next_p, modulo);
// gmp_printf("%Zd %Zd\n", next_p.x, next_p.y);
RDTSC_STOP(t2); // stop operation
total5 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[JACOBIAN-AFFINE] Sliding NAF Left to right binary algorithm (w = 5)--\n");
print_result(total5, one_us);
/** Test Right-to-left binary algorithm */
i = 0;
uint64_t total6 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
next_p = affine_right_to_left_binary(p, a, k, modulo); // Q = [k]P
// gmp_printf("%Zd %Zd\n", next_p.x, next_p.y);
RDTSC_STOP(t2); // stop operation
total6 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[AFFINE] Right to left binary algorithm--\n");
print_result(total6, one_us);
/** Test Montgomery ladder algorithm (Against time-based attack) */
i = 0;
uint64_t total7 = 0;
while (i < max_iteration) {
RDTSC_START(t1); // start operation
j_next_p = jacobian_montgomery_ladder(j_p, a, k, modulo); // Q = [k]P
// gmp_printf("%Zd %Zd\n", j_next_p.X, j_next_p.Y);
next_p = jacobian_to_affine(j_next_p, modulo);
// gmp_printf("%Zd %Zd\n", next_p.x, next_p.y);
RDTSC_STOP(t2); // stop operation
total7 += t2 - t1 - rdtscp_cycle;
i++;
}
printf("--[JACOBIAN] Montgomery ladder algorithm--\n");
print_result(total7, one_us);
}
/** -------------------------------------------------------------------------*/
J_Point public_key_1, public_key_2, shared_key;
mpz_t private_key_1, private_key_2;
mpz_init(private_key_1); mpz_init(private_key_2);
// TODO : Key should be padded to fixed size (serializable)
// Note: (2^-256 chance of failure, can be ignored)
while (mpz_cmp(private_key_1, zero_value) == 0) {
get_random(private_key_1, 32); // 256 bit
positive_modulo(private_key_1, private_key_1, modulo);
}
while (mpz_cmp(private_key_2, zero_value) == 0) {
get_random(private_key_2, 32); // 256 bit
positive_modulo(private_key_2, private_key_2, modulo);
}
gmp_printf("Private key [A B]: %Zd %Zd\n\n", private_key_1, private_key_2);
public_key_1 = jacobian_left_to_right_binary(j_p, a, private_key_1, modulo);
public_key_2 = jacobian_left_to_right_binary(j_p, a, private_key_2, modulo);
gmp_printf("Public key 1 - Jacobian [X Y Z]: %Zd %Zd %Zd\n", public_key_1.X, public_key_1.Y, public_key_1.Z);
gmp_printf("Public key 2 - Jacobian [X Y Z]: %Zd %Zd %Zd\n", public_key_2.X, public_key_2.Y, public_key_2.Z);
Point public_key_1_decoded = jacobian_to_affine(public_key_1, modulo);
Point public_key_2_decoded = jacobian_to_affine(public_key_2, modulo);
gmp_printf("Public key 1 - Affine [X Y]: %Zd %Zd\n", public_key_1_decoded.x, public_key_1_decoded.y);
gmp_printf("Public key 2 - Affine [X Y]: %Zd %Zd\n\n", public_key_2_decoded.x, public_key_2_decoded.y);
/** -------------------------------------------------------------------------*/
if (TEST_ENCRYPT_DECRYPT) {
// ElGamal Encrypt - Decrypt (Map message to chunk of points in EC)
J_Point message, chosen_point, encoded_point, decoded_point;
mpz_t k_message;
mpz_init(k_message);
mpz_set_ui(k_message, 123456789);
message = jacobian_left_to_right_binary(j_p, a, k_message, modulo);
Point message_decoded = jacobian_to_affine(message, modulo);
gmp_printf("[Encrypt] Message - Affine [X Y] %Zd %Zd\n", message_decoded.x, message_decoded.y);
gmp_printf("[Encrypt] Message - Jacobian [X Y Z]: %Zd %Zd %Zd\n", message.X, message.Y, message.Z);
while (mpz_cmp(k_message, zero_value) == 0) {
get_random(k_message, 32);
positive_modulo(k_message, k_message, modulo);
}
// Encrypt example
chosen_point = jacobian_left_to_right_binary(j_p, a, k_message, modulo); // chosen point (r)
gmp_printf("[Encrypt] Chosen point - Jacobian [X Y Z]: %Zd %Zd %Zd\n", chosen_point.X, chosen_point.Y, chosen_point.Z);
encoded_point = jacobian_left_to_right_binary(public_key_2, a, k_message, modulo); // r * Pu2
encoded_point = jacobian_curve_addition(message, encoded_point, a, modulo);
// TODO : chosen_point & encoded_point should be padded to P-bit
gmp_printf("[Decrypt] Encoded point - Jacobian [X Y Z]: %Zd %Zd %Zd\n", encoded_point.X, encoded_point.Y, encoded_point.Z);
// Decrypt example (encoded_point - private_key * chosen_point)
decoded_point = jacobian_left_to_right_binary(chosen_point, a, private_key_2, modulo);
decoded_point = jacobian_curve_subtraction(encoded_point, decoded_point, a, modulo);
gmp_printf("[Decrypt] Original message - Jacobian [X Y Z]: %Zd %Zd %Zd\n", decoded_point.X, decoded_point.Y, decoded_point.Z);
message_decoded = jacobian_to_affine(decoded_point, modulo);
gmp_printf("[Decrypt] Original message - Affine [X Y] %Zd %Zd\n\n", message_decoded.x, message_decoded.y);
}
/** -------------------------------------------------------------------------*/
if (TEST_SIMPLIFIED_ECIES) {
// Simplified ECIES (Ref: Page 256 Cryptography Theory & Practice 2nd Ed. - Douglas)
char* message_string = "hello"; // 0..9, a..z (base 36)
mpz_t encrypted_message;
mpz_init(encrypted_message);
int partition = strlen(message_string) / 24;
int partition_modulo = strlen(message_string) % 24;
if (partition_modulo != 0) partition++;
for (i = 0; i < partition; i++) {
// 24 characters from message_string + 1 null-terminate
char* chunked_message_string = (char*) malloc(25 * sizeof(char));
int size = 24;
if ((i == partition - 1) && (partition_modulo != 0)) size = partition_modulo;
strncpy(chunked_message_string, message_string + i*24, size);
chunked_message_string[size] = '\0'; // null-terminate
Point c_point = encrypt_ECIES(encrypted_message, chunked_message_string, public_key_2_decoded, p, a, modulo);
gmp_printf("[SIMPLIFIED ECIES] Encrypted message: %Zd\n", encrypted_message);
decrypt_ECIES(encrypted_message, c_point, private_key_2, p, a, modulo);
}
}
/**-------------------------------------------------------------------------*/
// TODO : Public key validation!
// Shared key (ECDH) - key secure exchange
shared_key = jacobian_left_to_right_binary(public_key_2, a, private_key_1, modulo);
gmp_printf("Shared key - Jacobian [X Y Z]: %Zd %Zd %Zd\n", shared_key.X, shared_key.Y, shared_key.Z);
Point shared_key_decoded = jacobian_to_affine(shared_key, modulo);
gmp_printf("Shared key - Affine [X Y]: %Zd %Zd\n", shared_key_decoded.x, shared_key_decoded.y);
// TODO : ECDSA - digital signature algorithm
/** Cleaning up */
mpz_clear(a);
mpz_clear(b);
mpz_clear(k);
mpz_clear(r);
mpz_clear(modulo);
mpz_clear(private_key_1);
mpz_clear(private_key_2);
return EXIT_SUCCESS;
}
inline
void
op_circshift::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_circshift>& in)
{
arma_extra_debug_sigprint();
typedef typename T1::elem_type eT;
const unwrap<T1> tmp(in.m);
const Mat<eT>& X = tmp.M;
if(X.is_empty()) { out.copy_size(X); return; }
const uword dim = in.aux_uword_a;
arma_debug_check( (dim > 1), "circshift(): dim must be 0 or 1" );
const uword shift = in.aux_uword_b;
const bool is_alias = (&out == &X);
uword xshift = 0;
uword yshift = 0;
uword xdim = X.n_cols;
uword ydim = X.n_rows;
if(is_alias == 0) {
out.copy_size(X);
if(dim == 0) {
xshift = shift;
for (uword i = 0; i < xdim; i++) {
uword ii = positive_modulo(i + xshift, xdim);
for (uword j = 0; j < ydim; j++) {
uword jj = positive_modulo(j + yshift, ydim);
out(jj,ii) = X(j,i);
}
}
} else {
yshift = shift;
for (uword i = 0; i < xdim; i++) {
uword ii = positive_modulo(i + xshift, xdim);
for (uword j = 0; j < ydim; j++) {
uword jj = positive_modulo(j + yshift, ydim);
out(jj,ii) = X(j,i);
}
}
}
} else { //X is an alias of out (same memory address)
Mat<eT> temp;
temp.copy_size(X);
temp = X;
if(dim == 0) {
xshift = shift;
for (uword i = 0; i < xdim; i++) {
uword ii = positive_modulo(i + xshift, xdim);
for (uword j = 0; j < ydim; j++) {
uword jj = positive_modulo(j + yshift, ydim);
out(jj,ii) = temp(j,i);
}
}
} else {
yshift = shift;
for (uword i = 0; i < xdim; i++) {
uword ii = positive_modulo(i + xshift, xdim);
for (uword j = 0; j < ydim; j++) {
uword jj = positive_modulo(j + yshift, ydim);
out(jj,ii) = temp(j,i);
}
}
}
}
}
