ctidh.c File Reference

#include <time.h>
#include <secsidh/secsidh.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "cycle.h"
#include "fp-counters.h"
#include "primes.h"
#include "ctidh.h"
#include "ctidh_api.h"
#include "fp/fp2.h"

Include dependency graph for ctidh.c:

Go to the source code of this file.

Macros
#define	cprintf(...)
#define	CPASTER(x, y)
#define	CEVALUATOR(x, y)
#define	CONSTNAMESPACE(name)
#define	SK_SIZE   CONSTNAMESPACE(SK_SIZE)
#define	PK_SIZE   CONSTNAMESPACE(PK_SIZE)
#define	SS_SIZE   CONSTNAMESPACE(SS_SIZE)
#define	pk_size   FNAMESPACE(pk_size)
#define	sk_size   FNAMESPACE(sk_size)
#define	ss_size   FNAMESPACE(ss_size)
#define	FPASTER(x, y)
#define	FEVALUATOR(x, y)
#define	FNAMESPACE(name)
#define	keygen   FNAMESPACE(keygen)
#define	derive   FNAMESPACE(derive)

Functions
int	main (int argc, char *argv[])

Macro Definition Documentation

CEVALUATOR

#define CEVALUATOR	(		x,
			y )

Value:

CPASTER(x, y)

Definition at line 24 of file ctidh.c.

CONSTNAMESPACE

#define CONSTNAMESPACE

(

name

)

Value:

CEVALUATOR(BITS, name)

Definition at line 25 of file ctidh.c.

CPASTER

#define CPASTER	(		x,
			y )

Value:

SECSIDH_CTIDH##x##_##y

Definition at line 23 of file ctidh.c.

cprintf

#define cprintf

(

...

)

Definition at line 20 of file ctidh.c.

Referenced by main().

derive

#define derive   FNAMESPACE(derive)

Definition at line 39 of file ctidh.c.

Referenced by main().

FEVALUATOR

#define FEVALUATOR	(		x,
			y )

Value:

FPASTER(x, y)

Definition at line 35 of file ctidh.c.

FNAMESPACE

#define FNAMESPACE

(

name

)

Value:

FEVALUATOR(BITS, name)

Definition at line 36 of file ctidh.c.

FPASTER

#define FPASTER	(		x,
			y )

Value:

secsidh_CTIDH##x##_##y

Definition at line 34 of file ctidh.c.

keygen

#define keygen   FNAMESPACE(keygen)

Definition at line 38 of file ctidh.c.

Referenced by main().

PK_SIZE

#define PK_SIZE   CONSTNAMESPACE(PK_SIZE)

Definition at line 27 of file ctidh.c.

pk_size

#define pk_size   FNAMESPACE(pk_size)

Definition at line 30 of file ctidh.c.

SK_SIZE

#define SK_SIZE   CONSTNAMESPACE(SK_SIZE)

Definition at line 26 of file ctidh.c.

sk_size

#define sk_size   FNAMESPACE(sk_size)

Definition at line 31 of file ctidh.c.

SS_SIZE

#define SS_SIZE   CONSTNAMESPACE(SS_SIZE)

Definition at line 28 of file ctidh.c.

ss_size

#define ss_size   FNAMESPACE(ss_size)

Definition at line 32 of file ctidh.c.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 59 of file ctidh.c.

{
#if !defined(_M1_) && !defined(_M2_) && !defined(_M3_) && !defined(_M4_) && !defined(_M5_)
    printf("\nNOT using radical 3-isogenies (original dCTIDH).\n\n");
#else
    printf("\nUsing 2^%ld radical 3-isogenies.\n\n", batch_start[0] - 1);
#endif
    if (argc == 3)
    {
        if (strcmp(argv[1], "-bact") == 0)
        {
            run_benchmark_action(atoi(argv[2]), 10);
        }
        else if (strcmp(argv[1], "-bkey") == 0)
        {
            run_benchmark_keygen(atoi(argv[2]), 10);
        }
        else if (strcmp(argv[1], "-bkey") == 0)
        {
            run_benchmark_fp(atoi(argv[2]));
        }
        else
        {
            printf("usage: \t%s\t\t\t\t// for a quick test\n\t%s -bact [number of runs]\t//run benchmark for the action\n\t%s -bfp [number of runs]\t//run benchmark for fp_mul", argv[0], argv[0], argv[0]);
        }
        return 0;
    }
    else if (argc == 2)
    {
 
        if (strcmp(argv[1], "-fp2test") == 0)
        {
            printf("Starting fp^2 test ...\n");
            fflush(stdout);
            fp2_test();
            printf("All tests passed!\n");
            return 0;
        }
        else
        {
            printf("usage: \t%s\t\t\t\t// for a quick test\n\t%s -bact [number of runs]\t//run benchmark for the action\n\t%s -bfp [number of runs]\t//run benchmark for fp_mul", argv[0], argv[0], argv[0]);
        }
    }
 
    ticks cc0, cc1; // for measuringthe clock cycles
    // printf("PK_SIZE = %d and pk_size = %d\n", (int)PK_SIZE, (int)pk_size);
    // printf("SK_SIZE = %d and sk_size = %d\n", (int)SK_SIZE, (int)sk_size);
    // printf("SS_SIZE = %d and ss_size = %d\n", (int)SS_SIZE, (int)ss_size);
    // assert(PK_SIZE == pk_size);
    // assert(SK_SIZE == sk_size);
    // assert(SS_SIZE == ss_size);
 
    //------------------------------------------------------
    // Key generation
    printf("\033[0;33m// --------------\033[0m\n");
    printf("\033[0;33m// Key generation\033[0m\n");
 
    printf("sizeof private key = %lu \n", sizeof(private_key));
    printf("sizeof public key = %lu \n", sizeof(public_key));
 
    // ----------
    // Alice
    printf("\n\033[0;35m// Alice\033[0m\n");
    // uint8_t a[sizeof(private_key)] = {0}, A[sizeof(public_key)] = {0}, ss_a[sizeof(public_key)];
    uint8_t a[SK_SIZE] = {0}, A[PK_SIZE] = {0}, ss_a[SS_SIZE];
    cc0 = getticks();
    keygen(A, a);
    cc1 = getticks();
    ss_print(a, "sk_a", SK_SIZE);
    ss_print(A, "pk_a", PK_SIZE);
    cprintf("Running-time (millions): %2.03lfM + %2.03lfS + %2.03lfa = \033[1;35m%2.03lfM\033[0m\n", (1.0 * fpmul) / 1000000.0, (1.0 * fpsqr) / 1000000.0, (1.0 * fpadd) / 1000000.0, (1.0 * (fpmul + fpsqr)) / 1000000.0);
    printf("Clock cycles (millions): \033[1;35m%7.03lf\033[0m\n", (1.0 * (cc1 - cc0)) / 1000000.0);
    // ----------
    // Bob
    printf("\n\033[0;34m// Bob\033[0m\n");
    uint8_t b[SK_SIZE], B[PK_SIZE], ss_b[SS_SIZE];
    cc0 = getticks();
    keygen(B, b);
    cc1 = getticks();
    ss_print(b, "sk_b", SK_SIZE);
    ss_print(B, "pk_b", PK_SIZE);
    cprintf("Running-time (millions): %2.03lfM + %2.03lfS + %2.03lfa = \033[1;34m%2.03lfM\033[0m\n", (1.0 * fpmul) / 1000000.0, (1.0 * fpsqr) / 1000000.0, (1.0 * fpadd) / 1000000.0, (1.0 * (fpmul + fpsqr)) / 1000000.0);
    printf("Clock cycles (millions): \033[1;34m%7.03lf\033[0m\n", (1.0 * (cc1 - cc0)) / 1000000.0);
 
    fflush(stdout);
    //------------------------------------------------------
    // Secret sharing derivation
    printf("\n\033[0;33m// -------------------------\033[0m\n");
    printf("\033[0;33m// Secret sharing generation\033[0m\n");
 
    // ----------------
    // Alice
    printf("\n\033[0;35m// Alice\033[0m\n");
    cc0 = getticks();
    assert(derive(ss_a, B, a) == 0);
    cc1 = getticks();
    ss_print(ss_a, "ss_a", SS_SIZE);
    cprintf("Running-time (millions) [without validation]: %2.03lfM + %2.03lfS + %2.03lfa = \033[1;35m%2.03lfM\033[0m\n",
            (1.0 * fpmul) / 1000000.0, (1.0 * fpsqr) / 1000000.0, (1.0 * fpadd) / 1000000.0, (1.0 * (fpmul + fpsqr)) / 1000000.0);
    printf("Clock cycles (millions) [including validation]: \033[1;35m%7.03lf\033[0m\n", (1.0 * (cc1 - cc0)) / 1000000.0);
 
    fflush(stdout);
    // ----------------
    // Bob
    printf("\n\033[0;34m// Bob\033[0m\n");
    cc0 = getticks();
    assert(derive(ss_b, A, b) == 0);
    cc1 = getticks();
    ss_print(ss_b, "ss_b", SS_SIZE);
    cprintf("Running-time (millions) [without validation]: %2.03lfM + %2.03lfS + %2.03lfa = \033[1;34m%ld\033[0m\n",
            (1.0 * fpmul) / 1000000.0, (1.0 * fpsqr) / 1000000.0, (1.0 * fpadd) / 1000000.0, (fpmul + fpsqr));
    printf("Clock cycles (millions) [including validation]: \033[1;34m%7.03lf\033[0m\n", (1.0 * (cc1 - cc0)) / 1000000.0);
    fflush(stdout);
    // =============================
    // Verifying same secret sharing
    assert(dumb_fp_isequal(ss_a, ss_b, SS_SIZE));
 
    //------------------------------------------------------
    printf("\n\033[0;32m// Successfully secret sharing computation!\033[0m\n");
    return 0;
}

References a, assert(), batch_start, cprintf, derive, fp2_test, keygen, PK_SIZE, SK_SIZE, and SS_SIZE.

Here is the call graph for this function: