Fix build errors for Curve448 code on Windows (VC-WIN32 and VC-WIN64A)

[openssl.git] / crypto / ec / curve448 / f_generic.c

diff --git a/crypto/ec/curve448/f_generic.c b/crypto/ec/curve448/f_generic.c
index fa60b746b574abb4f87430637e961de64641b331..2fa97e5aa50285def6aecd09844548a7f3f6fe17 100644 (file)
--- a/crypto/ec/curve448/f_generic.c
+++ b/crypto/ec/curve448/f_generic.c
@@ -11,25 +11,24 @@
  */
 #include "field.h"
 
-static const gf MODULUS =
-    { FIELD_LITERAL(0xffffffffffffff, 0xffffffffffffff, 0xffffffffffffff,
-                    0xffffffffffffff, 0xfffffffffffffe, 0xffffffffffffff,
-                    0xffffffffffffff, 0xffffffffffffff)
+static const gf MODULUS = {
+    FIELD_LITERAL(0xffffffffffffff, 0xffffffffffffff, 0xffffffffffffff,
+                  0xffffffffffffff, 0xfffffffffffffe, 0xffffffffffffff,
+                  0xffffffffffffff, 0xffffffffffffff)
 };
 
-/** Serialize to wire format. */
+/* Serialize to wire format. */
 void gf_serialize(uint8_t serial[SER_BYTES], const gf x, int with_hibit)
 {
     unsigned int j = 0, fill = 0;
     dword_t buffer = 0;
-    unsigned int i;
+    int i;
     gf red;
 
     gf_copy(red, x);
     gf_strong_reduce(red);
-    if (!with_hibit) {
+    if (!with_hibit)
         assert(gf_hibit(red) == 0);
-    }
 
     UNROLL for (i = 0; i < (with_hibit ? X_SER_BYTES : SER_BYTES); i++) {
         if (fill < 8 && j < NLIMBS) {
@@ -37,31 +36,31 @@ void gf_serialize(uint8_t serial[SER_BYTES], const gf x, int with_hibit)
             fill += LIMB_PLACE_VALUE(LIMBPERM(j));
             j++;
         }
-        serial[i] = buffer;
+        serial[i] = (uint8_t)buffer;
         fill -= 8;
         buffer >>= 8;
     }
 }
 
-/** Return high bit of x = low bit of 2x mod p */
+/* Return high bit of x = low bit of 2x mod p */
 mask_t gf_hibit(const gf x)
 {
     gf y;
     gf_add(y, x, x);
     gf_strong_reduce(y);
-    return -(y->limb[0] & 1);
+    return 0 - (y->limb[0] & 1);
 }
 
-/** Return high bit of x = low bit of 2x mod p */
+/* Return high bit of x = low bit of 2x mod p */
 mask_t gf_lobit(const gf x)
 {
     gf y;
     gf_copy(y, x);
     gf_strong_reduce(y);
-    return -(y->limb[0] & 1);
+    return 0 - (y->limb[0] & 1);
 }
 
-/** Deserialize from wire format; return -1 on success and 0 on failure. */
+/* Deserialize from wire format; return -1 on success and 0 on failure. */
 mask_t gf_deserialize(gf x, const uint8_t serial[SER_BYTES], int with_hibit,
                       uint8_t hi_nmask)
 {
@@ -81,19 +80,19 @@ mask_t gf_deserialize(gf x, const uint8_t serial[SER_BYTES], int with_hibit,
             fill += 8;
             j++;
         }
-        x->limb[LIMBPERM(i)] =
-            (i < NLIMBS - 1) ? buffer & LIMB_MASK(LIMBPERM(i)) : buffer;
+        x->limb[LIMBPERM(i)] = (word_t)
+            ((i < NLIMBS - 1) ? buffer & LIMB_MASK(LIMBPERM(i)) : buffer);
         fill -= LIMB_PLACE_VALUE(LIMBPERM(i));
         buffer >>= LIMB_PLACE_VALUE(LIMBPERM(i));
         scarry =
             (scarry + x->limb[LIMBPERM(i)] -
              MODULUS->limb[LIMBPERM(i)]) >> (8 * sizeof(word_t));
     }
-    succ = with_hibit ? -(mask_t) 1 : ~gf_hibit(x);
-    return succ & word_is_zero(buffer) & ~word_is_zero(scarry);
+    succ = with_hibit ? 0 - (mask_t) 1 : ~gf_hibit(x);
+    return succ & word_is_zero((word_t)buffer) & ~word_is_zero((word_t)scarry);
 }
 
-/** Reduce to canonical form. */
+/* Reduce to canonical form. */
 void gf_strong_reduce(gf a)
 {
     dsword_t scarry;
@@ -121,7 +120,7 @@ void gf_strong_reduce(gf a)
      */
     assert(word_is_zero(scarry) | word_is_zero(scarry + 1));
 
-    scarry_0 = scarry;
+    scarry_0 = (word_t)scarry;
 
     /* add it back */
     for (i = 0; i < NLIMBS; i++) {
@@ -135,7 +134,7 @@ void gf_strong_reduce(gf a)
     assert(word_is_zero(carry + scarry_0));
 }
 
-/** Subtract two gf elements d=a-b */
+/* Subtract two gf elements d=a-b */
 void gf_sub(gf d, const gf a, const gf b)
 {
     gf_sub_RAW(d, a, b);
@@ -143,14 +142,14 @@ void gf_sub(gf d, const gf a, const gf b)
     gf_weak_reduce(d);
 }
 
-/** Add two field elements d = a+b */
+/* Add two field elements d = a+b */
 void gf_add(gf d, const gf a, const gf b)
 {
     gf_add_RAW(d, a, b);
     gf_weak_reduce(d);
 }
 
-/** Compare a==b */
+/* Compare a==b */
 mask_t gf_eq(const gf a, const gf b)
 {
     gf c;
@@ -166,3 +165,36 @@ mask_t gf_eq(const gf a, const gf b)
 
     return word_is_zero(ret);
 }
+
+mask_t gf_isr(gf a, const gf x)
+{
+    gf L0, L1, L2;
+    gf_sqr(L1, x);
+    gf_mul(L2, x, L1);
+    gf_sqr(L1, L2);
+    gf_mul(L2, x, L1);
+    gf_sqrn(L1, L2, 3);
+    gf_mul(L0, L2, L1);
+    gf_sqrn(L1, L0, 3);
+    gf_mul(L0, L2, L1);
+    gf_sqrn(L2, L0, 9);
+    gf_mul(L1, L0, L2);
+    gf_sqr(L0, L1);
+    gf_mul(L2, x, L0);
+    gf_sqrn(L0, L2, 18);
+    gf_mul(L2, L1, L0);
+    gf_sqrn(L0, L2, 37);
+    gf_mul(L1, L2, L0);
+    gf_sqrn(L0, L1, 37);
+    gf_mul(L1, L2, L0);
+    gf_sqrn(L0, L1, 111);
+    gf_mul(L2, L1, L0);
+    gf_sqr(L0, L2);
+    gf_mul(L1, x, L0);
+    gf_sqrn(L0, L1, 223);
+    gf_mul(L1, L2, L0);
+    gf_sqr(L2, L1);
+    gf_mul(L0, L2, x);
+    gf_copy(a, L1);
+    return gf_eq(L0, ONE);
+}