search

relic-toolkit / relic

Code
Other
452 stars 179 forks source link

Problem while compiling #288

Closed Loryerba closed 6 months ago

Loryerba commented 6 months ago

I followed the Compilation phase in the wiki. cd relic-target cmake ../relic- works but when i enter make; i get this error "make: *** No targets specified and no makefile found. Stop." What can I do?

Thanks

dfaranha commented 6 months ago

Can you post the full transcript here? It looks like you have the wrong path in the cmake line.

Loryerba commented 6 months ago

I report you all the steps i've done until i get an error:

-- Building for: Visual Studio 17 2022 CMake Deprecation Warning at CMakeLists.txt:1 (cmake_minimum_required): Compatibility with CMake < 3.5 will be removed from a future version of CMake.

Update the VERSION argument value or use a ... suffix to tell CMake that the project does not need compatibility with older versions.

-- Selecting Windows SDK version 10.0.22621.0 to target Windows 10.0.22631. -- The C compiler identification is MSVC 19.39.33519.0 -- The CXX compiler identification is MSVC 19.39.33519.0 -- Detecting C compiler ABI info -- Detecting C compiler ABI info - done -- Check for working C compiler: C:/Program Files (x86)/Microsoft Visual Studio/2022/BuildTools/VC/Tools/MSVC/14.39.33519/bin/Hostx64/x64/cl.exe - skipped -- Detecting C compile features -- Detecting C compile features - done -- Detecting CXX compiler ABI info -- Detecting CXX compiler ABI info - done -- Check for working CXX compiler: C:/Program Files (x86)/Microsoft Visual Studio/2022/BuildTools/VC/Tools/MSVC/14.39.33519/bin/Hostx64/x64/cl.exe - skipped -- Detecting CXX compile features -- Detecting CXX compile features - done

-- Configuring RELIC 0.6.0...

-- Available switches (default = CHECK, VERBS, DOCUM):

DEBUG=[off|on] Build with debugging support. PROFL=[off|on] Build with profiling support. CHECK=[off|on] Build with error-checking support. VERBS=[off|on] Build with detailed error messages. OVERH=[off|on] Build with overhead estimation. DOCUM=[off|on] Build documentation. STRIP=[off|on] Build only selected algorithms. QUIET=[off|on] Build with printing disabled. COLOR=[off|on] Build with colored output. BIGED=[off|on] Build with big-endian support. SHLIB=[off|on] Build shared library. STLIB=[off|on] Build static library. STBIN=[off|on] Build static binaries. AMALG=[off|on] Build amalgamation for better performance. AUSAN=[off|on] Build with ASan and UBSan (gcc/clang only).

-- Number of times each test or benchmark is ran (default = 50, 1000):

TESTS=n If n > 0, build automated tests and run them n times. BENCH=n If n > 0, build automated benchmarks and run them n * n times.

-- Number of available processor cores (default = 1):

CORES=n If n > 1, enable multithreading support.

-- Available modules (default = ALL)

WITH=BN Multiple precision arithmetic. WITH=DV Temporary double-precision digit vectors. WITH=FP Prime field arithmetic. WITH=FPX Prime extension field arithmetic. WITH=FB Binary field arithmetic. WITH=EP Elliptic curves over prime fields. WITH=EPX Elliptic curves over quadratic extensions of prime fields. WITH=EB Elliptic curves over binary fields. WITH=ED Elliptic Edwards curves over prime fields. WTTH=EC Elliptic curve cryptography. WITH=PB Pairings over binary elliptic curves. WITH=PP Pairings over prime elliptic curves. WTTH=PC Pairing-based cryptography. WITH=BC Block ciphers (symmetric encryption). WITH=MD Message digests (hash functions). WITH=CP Cryptographic protocols. WITH=MPC Multi-party computation primitives. WITH=ALL All of the above. Note: the programmer is responsible for not using unselected modules.

-- Available arithmetic backends (default = easy):

ARITH=easy Easy-to-understand and portable, but slow backend. ARITH=fiat Backend based on code generated from Fiat-Crypto. ARITH=gmp Backend based on GNU Multiple Precision library.

ARITH=gmp-sec Same as above, but using constant-time code.

-- Available memory-allocation policies (default = AUTO):

ALLOC=AUTO All memory is automatically allocated. ALLOC=DYNAMIC All memory is allocated dynamically on demand.

-- Supported operating systems (default = LINUX):

OPSYS= Undefined/No specific operating system. OPSYS=LINUX GNU/Linux operating system. OPSYS=FREEBSD FreeBSD operating system. OPSYS=NETBSD NetBSD operating system. OPSYS=MACOSX Mac OS X operating system. OPSYS=WINDOWS Windows operating system. OPSYS=DROID Android operating system. OPSYS=DUINO Arduino platform.

-- Supported multithreading APIs (default = UNDEF):

MULTI= No multithreading support. MULTI=OPENMP Open Multi-Processing. MULTI=PTHREAD POSIX threads.

-- Supported timers (default = HREAL):

TIMER= No timer. TIMER=HREAL GNU/Linux realtime high-resolution timer. TIMER=HPROC GNU/Linux per-process high-resolution timer. TIMER=HTHRD GNU/Linux per-thread high-resolution timer. TIMER=ANSI ANSI-compatible timer. TIMER=POSIX POSIX-compatible timer. TIMER=CYCLE Cycle-counting timer. (architecture-dependant) TIMER=PERF GNU/Linux performance monitoring framework.

-- Prefix to identify this build of the library (default = ""):

LABEL=relic

-- Available architectures (default = X64):

ARCH= No specific architecture (disable some features). ARCH=AVR Atmel AVR ATMega128 8-bit architecture. ARCH=MSP TI MSP430 16-bit architecture. ARCH=ARM ARM 32-bit architecture. ARCH=X86 Intel x86-compatible 32-bit architecture. ARCH=X64 AMD x86_64-compatible 64-bit architecture.

-- Available word sizes (default = 64):

WSIZE=8 Build a 8-bit library. WSIZE=16 Build a 16-bit library. WSIZE=32 Build a 32-bit library. WSIZE=64 Build a 64-bit library.

-- Byte boundary to align digit vectors (default = 1):

ALIGN=1 Do not align digit vectors. ALIGN=2 Align digit vectors into 16-bit boundaries. ALIGN=8 Align digit vectors into 64-bit boundaries. ALIGN=16 Align digit vectors into 128-bit boundaries.

-- Looking for include file execinfo.h -- Looking for include file execinfo.h - not found -- Looking for backtrace -- Looking for backtrace - not found -- Looking for backtrace_symbols -- Looking for backtrace_symbols - not found -- Multiple precision arithmetic configuration (BN module):

** Options for the multiple precision module (default = 1024,DOUBLE,0):

  BN_PRECI=n        The base precision in bits. Let w be n in words.
  BN_MAGNI=DOUBLE   A multiple precision integer can store 2w words.
  BN_MAGNI=CARRY    A multiple precision integer can store w+1 words.
  BN_MAGNI=SINGLE   A multiple precision integer can store w words.
  BN_KARAT=n        The number of Karatsuba steps.

** Available multiple precision arithmetic methods (default = COMBA;COMBA;MONTY;SLIDE;BASIC;BASIC):

  Integer multiplication:
  BN_METHD=BASIC    Schoolbook multiplication.
  BN_METHD=COMBA    Comba multiplication.

  Integer squaring:
  BN_METHD=BASIC    Schoolbook squaring.
  BN_METHD=COMBA    Comba squaring.
  BN_METHD=MULTP    Reuse multiplication for squaring.

  Modular reduction:
  BN_METHD=BASIC    Division-based modular reduction.
  BN_METHD=BARRT    Barrett modular reduction.
  BN_METHD=MONTY    Montgomery modular reduction.
  BN_METHD=RADIX    Diminished radix modular reduction.

  Modular exponentiation:
  BN_METHD=BASIC    Binary modular exponentiation.
  BN_METHD=MONTY    Montgomery powering ladder.
  BN_METHD=SLIDE    Sliding window modular exponentiation.

  Greatest Common Divisor:
  BN_METHD=BASIC    Euclid's standard GCD algorithm.
  BN_METHD=BINAR    Binary GCD algorithm.
  BN_METHD=LEHME    Lehmer's fast GCD algorithm.

  Prime generation:
  BN_METHD=BASIC    Basic prime generation.
  BN_METHD=SAFEP    Safe prime generation.
  BN_METHD=STRON    Strong prime generation.

-- Prime field arithmetic configuration (FP module):

** Arithmetic precision of the prime field module (default = 256,0,off,off):

  FP_PRIME=n        The prime modulus size in bits.
  FP_KARAT=n        The number of Karatsuba levels.
  FP_PMERS=[off|on] Prefer Pseudo-Mersenne primes over random primes.
  FP_QNRES=[off|on] Use -1 as quadratic non-residue (make sure that p = 3 mod 8).
  FP_WIDTH=w        Width w in [2,6] of window processing for exponentiation methods.

** Available prime field arithmetic methods (default = BASIC;COMBA;COMBA;MONTY;MONTY;JMPDS;SLIDE): Field addition: FP_METHD=BASIC Schoolbook addition. FP_METHD=INTEG Integrated modular addition.

  Field multiplication:
  FP_METHD=BASIC    Schoolbook multiplication.
  FP_METHD=INTEG    Integrated modular multiplication.
  FP_METHD=COMBA    Comba multiplication.

  Field squaring:
  FP_METHD=BASIC    Schoolbook squaring.
  FP_METHD=INTEG    Integrated modular squaring.
  FP_METHD=COMBA    Comba squaring.
  FP_METHD=MULTP    Reuse multiplication for squaring.

  Modular reduction:
  FP_METHD=BASIC    Division-based reduction.
  FP_METHD=QUICK    Fast reduction modulo special form prime (2^t - c, c > 0).
  FP_METHD=MONTY    Montgomery modular reduction.

  Field inversion:
  FP_METHD=BASIC    Inversion by Fermat's Little Theorem.
  FP_METHD=BINAR    Binary Inversion algorithm.
  FP_METHD=MONTY    Montgomery inversion.
  FP_METHD=EXGCD    Inversion by the Extended Euclidean algorithm.
  FP_METHD=DIVST    Constant-time inversion by division steps.
  FP_METHD=LOWER    Pass inversion to the lower level.

  Legendre symbol:
  FP_METHD=BASIC    Computation by Fermat's Little Theorem.
  FP_METHD=BINAR    Binary algorithm.
  FP_METHD=DIVST    Constant-time method by division steps.
  FP_METHD=JMPDS    Constant-time method by jump division steps.
  FP_METHD=LOWER    Pass call to the lower level.

  Field exponentiation:
  FP_METHD=BASIC    Binary exponentiation.
  FP_METHD=SLIDE    Sliding window exponentiation.
  FP_METHD=MONTY    Constant-time Montgomery powering ladder.

-- Prime extension field arithmetic configuration (FPX module):

** Available bilinear pairing methods (default = BASIC;BASIC;BASIC): Quadratic extension arithmetic: FPX_METHD=BASIC Basic quadratic extension field arithmetic. FPX_METHD=INTEG Quadratic extension field arithmetic with embedded modular reduction.

  Cubic extension arithmetic:
  FPX_METHD=BASIC    Basic cubic extension field arithmetic.
  FPX_METHD=INTEG    Cubic extension field arithmetic with embedded modular reduction.

  Extension field arithmetic:
  FPX_METHD=BASIC    Basic extension field arithmetic.
  FPX_METHD=LAZYR    Lazy-reduced extension field arithmetic.

-- Binary field arithmetic configuration (FB module):

** Options for the binary elliptic curve module (default = 283,0,on,on,on):

  FB_POLYN=n        The irreducible polynomial size in bits.
  FB_KARAT=n        The number of Karatsuba levels.
  FB_TRINO=[off|on] Prefer trinomials.
  FB_SQRTF=[off|on] Prefer square-root friendly polynomials.
  FB_PRECO=[off|on] Precompute multiplication table for sqrt(z).
  FB_WIDTH=w        Width w in [2,6] of window processing for exponentiation methods.

** Available binary field arithmetic methods (default = LODAH;QUICK;QUICK;BASIC;QUICK;QUICK;EXGCD;SLIDE;QUICK):

  Field multiplication:
  FB_METHD=BASIC    Right-to-left shift-and-add multiplication.
  FB_METHD=INTEG    Integrated modular multiplication.
  FB_METHD=LODAH    L�pez-Dahab comb multiplication with window of width 4.

  Field squaring:
  FB_METHD=BASIC    Bit manipulation squaring.
  FB_METHD=INTEG    Integrated modular squaring.
  FB_METHD=QUICK    Table-based squaring.

  Modular reduction:
  FB_METHD=BASIC    Shift-and-add modular reduction.
  FB_METHD=QUICK    Fast reduction modulo a trinomial or pentanomial.

  Field square root:
  FB_METHD=BASIC    Square root by repeated squaring.
  FB_METHD=QUICK    Fast square root extraction.

  Trace computation:
  FB_METHD=BASIC    Trace computation by repeated squaring.
  FB_METHD=QUICK    Fast trace computation.

  Quadratic equation solver:
  FB_METHD=BASIC    Solve a quadratic equation by half-trace computation.
  FB_METHD=QUICK    Fast solving with precomputed half-traces.

  Field inversion:
  FB_METHD=BASIC    Inversion by Fermat's Little Theorem.
  FB_METHD=BINAR    Binary Inversion algorithm.
  FB_METHD=ALMOS    Inversion by the Amost inverse algorithm.
  FB_METHD=EXGCD    Inversion by the Extended Euclidean algorithm.
  FB_METHD=ITOHT    Inversion by Itoh-Tsuji.
  FB_METHD=CTAIA    Constant-time almost inversion algorithm.
  FB_METHD=BRUCH    Hardware-friendly inversion by Brunner et al.
  FB_METHD=LOWER    Pass inversion to the lower level.

  Field exponentiation:
  FB_METHD=BASIC    Binary exponentiation.
  FB_METHD=SLIDE    Sliding window exponentiation.
  FB_METHD=MONTY    Constant-time Montgomery powering ladder.

  Iterated squaring/square-root:
  FB_METHD=BASIC    Iterated squaring/square-root by consecutive squaring/square-root.
  FB_METHD=QUICK    Iterated squaring/square-root by table-based method.

-- Prime elliptic curve arithmetic configuration (EP module):

** Options for the prime elliptic curve module (default = all on):

  EP_PLAIN=[off|on] Support for ordinary curves without endomorphisms.
  EP_SUPER=[off|on] Support for supersingular curves.
  EP_ENDOM=[off|on] Support for ordinary curves with endomorphisms.
  EP_MIXED=[off|on] Use mixed coordinates.
  EP_CTMAP=[off|on] Use contant-time SSWU and isogeny map for hashing.

  EP_PRECO=[off|on] Build precomputation table for generator.
  EP_DEPTH=w        Width w in [2,8] of precomputation table for fixed point methods.
  EP_WIDTH=w        Width w in [2,6] of window processing for unknown point methods.

** Available prime elliptic curve methods (default = PROJC;LWNAF;COMBS;INTER):

  Point representation:
  EP_METHD=BASIC    Affine coordinates.
  EP_METHD=PROJC    Homogeneous projective coordinates (complete formula).
  EP_METHD=JACOB    Jacobian projective coordinates.

  Variable-base scalar multiplication:
  EP_METHD=SLIDE    Sliding window method.
  EP_METHD=MONTY    Montgomery ladder method.
  EP_METHD=LWNAF    Left-to-right window NAF method.
  EP_METHD=LWREG    Left-to-right regular recoding method (GLV for curves with endomorphisms).

  Fixed-base scalar multiplication:
  EP_METHD=BASIC    Binary method for fixed point multiplication.
  EP_METHD=COMBS    Single-table Comb method for fixed point multiplication.
  EP_METHD=COMBD    Double-table Comb method for fixed point multiplication.
  EP_METHD=LWNAF    Left-to-right window NAF method (GLV for curves with endomorphisms).

  Variable-base simultaneous scalar multiplication:
  EP_METHD=BASIC    Multiplication-and-addition simultaneous multiplication.
  EP_METHD=TRICK    Shamir's trick for simultaneous multiplication.
  EP_METHD=INTER    Interleaving of window NAFs (GLV for Koblitz curves).
  EP_METHD=JOINT    Joint sparse form.

-- Binary elliptic curve arithmetic configuration (EB module):

** Options for the binary elliptic curve module (default = on, w = 4):

  EB_PLAIN=[off|on] Support for ordinary curves without endomorphisms.
  EB_KBLTZ=[off|on] Support for Koblitz anomalous binary curves.
  EB_MIXED=[off|on] Use mixed coordinates.
  EB_PRECO=[off|on] Build precomputation table for generator.
  EB_DEPTH=w        Width w in [2,8] of precomputation table for fixed point methods.
  EB_WIDTH=w        Width w in [2,6] of window processing for unknown point methods.

** Available binary elliptic curve methods (default = PROJC;LWNAF;COMBS;INTER):

  Point representation:
  EB_METHD=BASIC    Affine coordinates.
  EB_METHD=PROJC    Projective coordinates (L�pez-Dahab for ordinary curves).

  Variable-base scalar multiplication:
  EB_METHD=BASIC    Binary double-and-add method.
  EB_METHD=LODAH    Lopez-Dahab constant-time point multiplication.
  EB_METHD=LWNAF    Left-to-right window (T)NAF method.
  EB_METHD=RWNAF    Right-to-left window (T)NAF method.
  EB_METHD=HALVE    Halving method.

  Fixed-base scalar multiplication:
  EB_METHD=BASIC    Binary method for fixed point multiplication.
  EB_METHD=COMBS    Single-table Comb method for fixed point multiplication.
  EB_METHD=COMBD    Double-table Comb method for fixed point multiplication.
  EB_METHD=LWNAF    Left-to-right window (T)NAF method.

  Variable-base simultaneous scalar multiplication:
  EB_METHD=BASIC    Multiplication-and-addition simultaneous multiplication.
  EB_METHD=TRICK    Shamir's trick for simultaneous multiplication.
  EB_METHD=INTER    Interleaving of window (T)NAFs.
  EB_METHD=JOINT    Joint sparse form.

-- Elliptic Edwards curve over prime fields arithmetic configuration (ED module):

** Options for the prime elliptic Edwards curve module (default = all on): ED_PRECO=[off|on] Build precomputation table for generator. ED_DEPTH=w Width w in [2,6] of precomputation table for fixed point methods. ED_WIDTH=w Width w in [2,6] of window processing for unknown point methods.

** Available prime elliptic Edwards curve methods (default = PROJC;LWNAF;COMBS;INTER): ED_METHD=BASIC Affine coordinates. EP_METHD=PROJC Simple projective twisted Edwards coordinates. EP_METHD=EXTND Extended projective twisted Edwards coordinates.

  *** variable-base multiplication method ***
  ED_METHD=BASIC    Binary method.
  ED_METHD=SLIDE    Sliding window method.
  ED_METHD=MONTY    Montgomery ladder method.
  ED_METHD=LWNAF    Left-to-right window NAF method.
  EP_METHD=LWREG    Left-to-right regular recoding method (GLV for curves with endomorphisms).

  *** fixed-base multiplication method ***
  ED_METHD=BASIC    Binary method for fixed point multiplication.
  ED_METHD=COMBS    Single-table Comb method for fixed point multiplication.
  ED_METHD=COMBD    Double-table Comb method for fixed point multiplication.
  ED_METHD=LWNAF    Left-to-right window NAF method.

  *** variable-base simultaneous multiplication method ***
  ED_METHD=BASIC    Multiplication-and-addition simultaneous multiplication.
  ED_METHD=TRICK    Shamir's trick for simultaneous multiplication.
  ED_METHD=INTER    Interleaving of window NAFs (GLV for Koblitz curves).
  ED_METHD=JOINT    Joint sparse form.

  Note: these methods must be given in order. Ex: ED_METHD="EXTND;LWNAF;COMBD;TRICK"

-- Elliptic curve cryptography configuration (EC module):

** Options for the binary elliptic curve module (default = on):

  EC_ENDOM=[off|on] Prefer (prime or binary) curves with endomorphisms.

** Available elliptic curve methods (default = PRIME):

  EC_METHD=PRIME    Use prime curves.
  EC_METHD=CHAR2    Use binary curves.
  EC_METHD=EDDIE    Use prime Edwards curves.

-- Bilinear pairings arithmetic configuration (PP module):

** Available bilinear pairing methods (default = BASIC;OATEP):

  Extension field arithmetic:
  PP_METHD=BASIC    Basic extension field arithmetic.
  PP_METHD=LAZYR    Lazy reduced extension field arithmetic.

  Pairing computation:
  PP_METHD=TATEP    Tate pairing.
  PP_METHD=WEILP    Weil pairing.
  PP_METHD=OATEP    Optimal ate pairing.

-- Message digest configuration (MD module):

** Available hash functions (default = SH256):

  MD_METHD=SH224        SHA-224 hash function.
  MD_METHD=SH256        SHA-256 hash function.
  MD_METHD=SH384        SHA-384 hash function.
  MD_METHD=SH512        SHA-512 hash function.
  MD_METHD=B2S160       BLAKE2s-160 hash function.
  MD_METHD=B2S256       BLAKE2s-256 hash function.

-- Cryptographic protocols configuration (CP module):

** Options for the cryptographic protocols module (default = on, PKCS2):

  CP_CRT=[off|on] Support for faster CRT-based exponentiation in factoring-based cryptosystems.

  CP_RSAPD=BASIC    RSA with basic padding.
  CP_RSAPD=PKCS1    RSA with PKCS#1 v1.5 padding.
  CP_RSAPD=PKCS2    RSA with PKCS#1 v2.1 padding.

-- Available pseudo-random number generators (default = HASHD):

RAND=HASHD Use the HASH-DRBG generator. (recommended) RAND=RDRND Use Intel RdRand instruction directly. RAND=UDEV Use the operating system underlying generator. RAND=CALL Override the generator with a callback.

-- Available random number generator seeders (default = UDEV):

SEED= Use a zero seed. (horribly insecure!) SEED=LIBC Use rand()/random() functions. (insecure!) SEED=RDRND Use Intel RdRand instruction directly. SEED=UDEV Use non-blocking /dev/urandom. (recommended) SEED=WCGR Use Windows' CryptGenRandom. (recommended)

-- Configured operating system: WINDOWS -- Supported MSVC runtime libraries (default = MD):

RUNTIME=MD DLL runtime library (/MD,/MDd). RUNTIME=MT Static runtime library (/MT,/MTd).

-- Compiler flags: -m64 -Wall /O2 -- Linker flags: -LC:/Users/Lorenzo/Downloads/relicpy/relic-0.6.0/src/low/easy/ -- Configured C:/Users/Lorenzo/Downloads/relicpy/relic-0.6.0/include/relic_conf.h.in with backend easy -- Could NOT find Doxygen (missing: DOXYGEN_EXECUTABLE) -- Configuring done (10.9s) -- Generating done (0.8s) -- Build files have been written to: C:/Users/Lorenzo/Downloads/relicpy/relic-target

Then running "make;" command i get this error: make: *** No targets specified and no makefile found. Stop.

thank you

Loryerba commented 6 months ago

It sounds that there isn't makefile in the relic-target folder. The "cmake ../relic-0.6.0" command inside the relic-target folder seems to work but when i type make, i got stuck. @dfaranha thank you a lot ;)

dfaranha commented 6 months ago

It will be hard to reproduce because you're based on Windows. Can you check if you have an empty relic-target folder?

Loryerba commented 6 months ago

when i type "mkdir -p relic-target" the folder is empty, then when i run "cmake ../relic-0.6.0" in the relic-target folder then this folder contains some files like these: img1 Im trying to install relic library because i need it for installing relic-toolkit library in python

dfaranha commented 6 months ago

Oh, because you're in Windows CMake generated a VStudio project that you can try to build.

The way we call CMake to get Makefiles on Windows is:

cmake -G "NMake Makefiles" path

Loryerba commented 6 months ago

Should i run this command on powershell or just compiling the vstudio project ?

dfaranha commented 6 months ago

You can try both and see if any end up working.

Loryerba commented 6 months ago

After compiling the Relic Solution on VStudio what should i get? The compilation phase is done but when i try to install relic-toolkit via pip on python i get the same error. If i try to run make; or make install i get always "make: *** No targets specified and no makefile found. Stop."

dfaranha commented 6 months ago

I'm not a Visual Studio user, so I don't know exactly what you should get. Probably a shared library that you can link against?

For the solution using make you need to generate the Makefiles and target directory from scratch using the -G switch above.

Loryerba commented 6 months ago

Hi @dfaranha i found a better way to install relic library via WSL on my windows machine. Thank you and have a good day ;)

Loryerba commented 6 months ago

Solved by using WSL machine on Windows 11 info : https://learn.microsoft.com/en-us/windows/wsl/install