Problem while compiling about relic HOT 12 CLOSED

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

from relic.

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

• Extract the folder "relic-0.6.0" from the "relic-0.6.0.tar.gz" with tar command
• mkdir -p relic-target
• cd relic-target
• cmake ../relic-0.6.0 and obtain:

-- 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

from relic.

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 ;)

from relic.

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

from relic.

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:

Im trying to install relic library because i need it for installing relic-toolkit library in python

from relic.

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

from relic.

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

from relic.

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

from relic.

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."

from relic.

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.

from relic.

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

from relic.

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

from relic.