Fix warning build in mbedtls

library/asn1parse.c

@@ -344,7 +344,7 @@ int mbedtls_asn1_get_sequence_of(unsigned char **p,
     asn1_get_sequence_of_cb_ctx_t cb_ctx = { tag, cur };
     memset(cur, 0, sizeof(mbedtls_asn1_sequence));
     return mbedtls_asn1_traverse_sequence_of(
-        p, end, 0xFF, tag, 0, 0,
+        p, end, 0xFF, (unsigned char) tag, 0, 0,
         asn1_get_sequence_of_cb, &cb_ctx);
 }
 

library/asn1write.c

@@ -72,9 +72,12 @@ static int mbedtls_asn1_write_len_and_tag(unsigned char **p,
                                           unsigned char tag)
 {
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
+    int tmp_len;
 
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(p, start, len));
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(p, start, tag));
+    tmp_len = (int) len;
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_len(p, start, len));
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_tag(p, start, tag));
+    len = (size_t) tmp_len;
 
     return (int) len;
 }
@@ -149,9 +152,12 @@ int mbedtls_asn1_write_oid(unsigned char **p, const unsigned char *start,
 {
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
     size_t len = 0;
+    int tmp_len;
 
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_raw_buffer(p, start,
+    tmp_len = (int) len;
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_raw_buffer(p, start,
                                                             (const unsigned char *) oid, oid_len));
+    len = (size_t) tmp_len;
     return mbedtls_asn1_write_len_and_tag(p, start, len, MBEDTLS_ASN1_OID);
 }
 
@@ -168,17 +174,20 @@ int mbedtls_asn1_write_algorithm_identifier_ext(unsigned char **p, const unsigne
 {
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
     size_t len = 0;
+    int tmp_len;
 
+    tmp_len = (int) len;
     if (has_par) {
         if (par_len == 0) {
-            MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_null(p, start));
+            MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_null(p, start));
         } else {
-            len += par_len;
+            tmp_len += (int) par_len;
         }
     }
 
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_oid(p, start, oid, oid_len));
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_oid(p, start, oid, oid_len));
 
+    len = (size_t) tmp_len;
     return mbedtls_asn1_write_len_and_tag(p, start, len,
                                           MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQUENCE);
 }
@@ -218,7 +227,7 @@ static int asn1_write_tagged_int(unsigned char **p, const unsigned char *start,
         len += 1;
     }
 
-    return mbedtls_asn1_write_len_and_tag(p, start, len, tag);
+    return mbedtls_asn1_write_len_and_tag(p, start, len, (unsigned char) tag);
 }
 
 int mbedtls_asn1_write_int(unsigned char **p, const unsigned char *start, int val)
@@ -236,12 +245,15 @@ int mbedtls_asn1_write_tagged_string(unsigned char **p, const unsigned char *sta
 {
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
     size_t len = 0;
+    int tmp_len;
 
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_raw_buffer(p, start,
+    tmp_len = (int) len;
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_raw_buffer(p, start,
                                                             (const unsigned char *) text,
                                                             text_len));
+    len = (size_t) tmp_len;
 
-    return mbedtls_asn1_write_len_and_tag(p, start, len, tag);
+    return mbedtls_asn1_write_len_and_tag(p, start, len, (unsigned char) tag);
 }
 
 int mbedtls_asn1_write_utf8_string(unsigned char **p, const unsigned char *start,
@@ -341,8 +353,11 @@ int mbedtls_asn1_write_octet_string(unsigned char **p, const unsigned char *star
 {
     int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
     size_t len = 0;
+    int tmp_len;
 
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_raw_buffer(p, start, buf, size));
+    tmp_len = (int) len;
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_raw_buffer(p, start, buf, size));
+    len = (size_t) tmp_len;
 
     return mbedtls_asn1_write_len_and_tag(p, start, len, MBEDTLS_ASN1_OCTET_STRING);
 }

library/base64.c

@@ -210,7 +210,7 @@ int mbedtls_base64_decode(unsigned char *dst, size_t dlen, size_t *olen,
         if (*src == '=') {
             ++equals;
         } else {
-            x |= mbedtls_ct_base64_dec_value(*src);
+            x |= (uint32_t) mbedtls_ct_base64_dec_value(*src);
         }
 
         if (++accumulated_digits == 4) {

library/bignum.c

@@ -48,7 +48,7 @@
 static inline signed short mbedtls_ct_mpi_sign_if(mbedtls_ct_condition_t cond,
                                                   signed short sign1, signed short sign2)
 {
-    return (signed short) mbedtls_ct_uint_if(cond, sign1 + 1, sign2 + 1) - 1;
+    return (signed short) mbedtls_ct_uint_if(cond, (unsigned) sign1 + 1, (unsigned) sign2 + 1) - 1;
 }
 
 /*
@@ -164,7 +164,7 @@ int mbedtls_mpi_safe_cond_swap(mbedtls_mpi *X,
 
     s = X->s;
     X->s = mbedtls_ct_mpi_sign_if(do_swap, Y->s, X->s);
-    Y->s = mbedtls_ct_mpi_sign_if(do_swap, s, Y->s);
+    Y->s = mbedtls_ct_mpi_sign_if(do_swap, (signed short) s, Y->s);
 
     mbedtls_mpi_core_cond_swap(X->p, Y->p, X->n, do_swap);
 
@@ -358,7 +358,7 @@ void mbedtls_mpi_swap(mbedtls_mpi *X, mbedtls_mpi *Y)
 static inline mbedtls_mpi_uint mpi_sint_abs(mbedtls_mpi_sint z)
 {
     if (z >= 0) {
-        return z;
+        return (mbedtls_mpi_uint) z;
     }
     /* Take care to handle the most negative value (-2^(biL-1)) correctly.
      * A naive -z would have undefined behavior.
@@ -382,7 +382,7 @@ int mbedtls_mpi_lset(mbedtls_mpi *X, mbedtls_mpi_sint z)
     memset(X->p, 0, X->n * ciL);
 
     X->p[0] = mpi_sint_abs(z);
-    X->s    = TO_SIGN(z);
+    X->s    = (short) TO_SIGN(z);
 
 cleanup:
 
@@ -450,7 +450,7 @@ size_t mbedtls_mpi_lsb(const mbedtls_mpi *X)
 #if defined(mbedtls_mpi_uint_ctz)
     for (i = 0; i < X->n; i++) {
         if (X->p[i] != 0) {
-            return i * biL + mbedtls_mpi_uint_ctz(X->p[i]);
+            return i * biL + (unsigned int) mbedtls_mpi_uint_ctz(X->p[i]);
         }
     }
 #else
@@ -555,8 +555,8 @@ int mbedtls_mpi_read_string(mbedtls_mpi *X, int radix, const char *s)
 
         for (i = 0; i < slen; i++) {
             MBEDTLS_MPI_CHK(mpi_get_digit(&d, radix, s[i]));
-            MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int(&T, X, radix));
-            MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(X, &T, d));
+            MBEDTLS_MPI_CHK(mbedtls_mpi_mul_int(&T, X, (mbedtls_mpi_uint) radix));
+            MBEDTLS_MPI_CHK(mbedtls_mpi_add_int(X, &T, (mbedtls_mpi_sint) d));
         }
     }
 
@@ -987,7 +987,7 @@ int mbedtls_mpi_cmp_int(const mbedtls_mpi *X, mbedtls_mpi_sint z)
     mbedtls_mpi_uint p[1];
 
     *p  = mpi_sint_abs(z);
-    Y.s = TO_SIGN(z);
+    Y.s = (short) TO_SIGN(z);
     Y.n = 1;
     Y.p = p;
 
@@ -1123,15 +1123,15 @@ static int add_sub_mpi(mbedtls_mpi *X,
             /* If |A| = |B|, the result is 0 and we must set the sign bit
              * to +1 regardless of which of A or B was negative. Otherwise,
              * since |A| > |B|, the sign is the sign of A. */
-            X->s = cmp == 0 ? 1 : s;
+            X->s = cmp == 0 ? 1 : (short) s;
         } else {
             MBEDTLS_MPI_CHK(mbedtls_mpi_sub_abs(X, B, A));
             /* Since |A| < |B|, the sign is the opposite of A. */
-            X->s = -s;
+            X->s = (short) -s;
         }
     } else {
         MBEDTLS_MPI_CHK(mbedtls_mpi_add_abs(X, A, B));
-        X->s = s;
+        X->s = (short) s;
     }
 
 cleanup:
@@ -1164,7 +1164,7 @@ int mbedtls_mpi_add_int(mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b
     mbedtls_mpi_uint p[1];
 
     p[0] = mpi_sint_abs(b);
-    B.s = TO_SIGN(b);
+    B.s = (short) TO_SIGN(b);
     B.n = 1;
     B.p = p;
 
@@ -1180,7 +1180,7 @@ int mbedtls_mpi_sub_int(mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b
     mbedtls_mpi_uint p[1];
 
     p[0] = mpi_sint_abs(b);
-    B.s = TO_SIGN(b);
+    B.s = (short) TO_SIGN(b);
     B.n = 1;
     B.p = p;
 
@@ -1521,7 +1521,7 @@ int mbedtls_mpi_div_int(mbedtls_mpi *Q, mbedtls_mpi *R,
     mbedtls_mpi_uint p[1];
 
     p[0] = mpi_sint_abs(b);
-    B.s = TO_SIGN(b);
+    B.s = (short) TO_SIGN(b);
     B.n = 1;
     B.p = p;
 
@@ -1589,21 +1589,21 @@ int mbedtls_mpi_mod_int(mbedtls_mpi_uint *r, const mbedtls_mpi *A, mbedtls_mpi_s
     for (i = A->n, y = 0; i > 0; i--) {
         x  = A->p[i - 1];
         y  = (y << biH) | (x >> biH);
-        z  = y / b;
-        y -= z * b;
+        z  = y / (mbedtls_mpi_uint) b;
+        y -= z * (mbedtls_mpi_uint) b;
 
         x <<= biH;
         y  = (y << biH) | (x >> biH);
-        z  = y / b;
-        y -= z * b;
+        z  = y / (mbedtls_mpi_uint) b;
+        y -= z * (mbedtls_mpi_uint) b;
     }
 
     /*
      * If A is negative, then the current y represents a negative value.
      * Flipping it to the positive side.
      */
     if (A->s < 0 && y != 0) {
-        y = b - y;
+        y = (mbedtls_mpi_uint) b - y;
     }
 
     *r = y;
@@ -1895,7 +1895,7 @@ int mbedtls_mpi_random(mbedtls_mpi *X,
         return ret;
     }
 
-    return mbedtls_mpi_core_random(X->p, min, N->p, X->n, f_rng, p_rng);
+    return mbedtls_mpi_core_random(X->p, (mbedtls_mpi_uint) min, N->p, X->n, f_rng, p_rng);
 }
 
 /*
@@ -2035,9 +2035,9 @@ static int mpi_check_small_factors(const mbedtls_mpi *X)
     }
 
     for (i = 0; i < sizeof(small_prime_gaps); p += small_prime_gaps[i], i++) {
-        MBEDTLS_MPI_CHK(mbedtls_mpi_mod_int(&r, X, p));
+        MBEDTLS_MPI_CHK(mbedtls_mpi_mod_int(&r, X, (mbedtls_mpi_sint) p));
         if (r == 0) {
-            if (mbedtls_mpi_cmp_int(X, p) == 0) {
+            if (mbedtls_mpi_cmp_int(X, (mbedtls_mpi_sint) p) == 0) {
                 return 1;
             } else {
                 return MBEDTLS_ERR_MPI_NOT_ACCEPTABLE;
@@ -2169,7 +2169,7 @@ int mbedtls_mpi_is_prime_ext(const mbedtls_mpi *X, int rounds,
         return ret;
     }
 
-    return mpi_miller_rabin(&XX, rounds, f_rng, p_rng);
+    return mpi_miller_rabin(&XX, (size_t) rounds, f_rng, p_rng);
 }
 
 /*
@@ -2268,9 +2268,9 @@ int mbedtls_mpi_gen_prime(mbedtls_mpi *X, size_t nbits, int flags,
                  */
                 if ((ret = mpi_check_small_factors(X)) == 0 &&
                     (ret = mpi_check_small_factors(&Y)) == 0 &&
-                    (ret = mpi_miller_rabin(X, rounds, f_rng, p_rng))
+                    (ret = mpi_miller_rabin(X, (size_t) rounds, f_rng, p_rng))
                     == 0 &&
-                    (ret = mpi_miller_rabin(&Y, rounds, f_rng, p_rng))
+                    (ret = mpi_miller_rabin(&Y, (size_t) rounds, f_rng, p_rng))
                     == 0) {
                     goto cleanup;
                 }

library/bignum_core.c

@@ -58,7 +58,7 @@ size_t mbedtls_mpi_core_bitlen(const mbedtls_mpi_uint *A, size_t A_limbs)
     for (i = ((int) A_limbs) - 1; i >= 0; i--) {
         if (A[i] != 0) {
             j = biL - mbedtls_mpi_core_clz(A[i]);
-            return (i * biL) + j;
+            return ((unsigned int) i * biL) + j;
         }
     }
 

library/constant_time.c

@@ -159,9 +159,9 @@ void mbedtls_ct_memmove_left(void *start, size_t total, size_t offset)
         for (size_t n = 0; n < total - 1; n++) {
             unsigned char current = buf[n];
             unsigned char next    = buf[n+1];
-            buf[n] = mbedtls_ct_uint_if(no_op, current, next);
+            buf[n] = (unsigned char) mbedtls_ct_uint_if(no_op, current, next);
         }
-        buf[total-1] = mbedtls_ct_uint_if_else_0(no_op, buf[total-1]);
+        buf[total-1] = (unsigned char) mbedtls_ct_uint_if_else_0(no_op, buf[total-1]);
     }
 }
 

library/constant_time_impl.h

@@ -204,7 +204,8 @@ static inline mbedtls_ct_condition_t mbedtls_ct_bool(mbedtls_ct_uint_t x)
 #pragma warning( disable : 4146 )
 #endif
     // y is negative (i.e., top bit set) iff x is non-zero
-    mbedtls_ct_int_t y = (-xo) | -(xo >> 1);
+    mbedtls_ct_int_t y;
+    y = (mbedtls_ct_int_t) ((-xo) | -(xo >> 1));
 
     // extract only the sign bit of y so that y == 1 (if x is non-zero) or 0 (if x is zero)
     y = (((mbedtls_ct_uint_t) y) >> (MBEDTLS_CT_SIZE - 1));
@@ -498,7 +499,7 @@ static inline int mbedtls_ct_error_if(mbedtls_ct_condition_t condition, int if1,
 
 static inline int mbedtls_ct_error_if_else_0(mbedtls_ct_condition_t condition, int if1)
 {
-    return -((int) (condition & (-if1)));
+    return -((int) (condition & (mbedtls_ct_condition_t) (-if1)));
 }
 
 static inline mbedtls_ct_condition_t mbedtls_ct_uint_eq(mbedtls_ct_uint_t x,

library/ecdsa.c

@@ -614,14 +614,18 @@ static int ecdsa_signature_to_asn1(const mbedtls_mpi *r, const mbedtls_mpi *s,
     unsigned char buf[MBEDTLS_ECDSA_MAX_LEN] = { 0 };
     unsigned char *p = buf + sizeof(buf);
     size_t len = 0;
+    int tmp_len;
 
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_mpi(&p, buf, s));
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_mpi(&p, buf, r));
+    tmp_len = (int) len;
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_mpi(&p, buf, s));
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_mpi(&p, buf, r));
 
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_len(&p, buf, len));
-    MBEDTLS_ASN1_CHK_ADD(len, mbedtls_asn1_write_tag(&p, buf,
+    len = (size_t) tmp_len;
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_len(&p, buf, len));
+    MBEDTLS_ASN1_CHK_ADD(tmp_len, mbedtls_asn1_write_tag(&p, buf,
                                                      MBEDTLS_ASN1_CONSTRUCTED |
                                                      MBEDTLS_ASN1_SEQUENCE));
+    len = (size_t) tmp_len;
 
     if (len > sig_size) {
         return MBEDTLS_ERR_ECP_BUFFER_TOO_SMALL;

library/lmots.c

@@ -90,7 +90,7 @@ static unsigned short lmots_checksum_calculate(const mbedtls_lmots_parameters_t
         sum += DIGIT_MAX_VALUE - digest[idx];
     }
 
-    return sum;
+    return (unsigned short) sum;
 }
 
 /* Create the string of digest digits (in the base determined by the Winternitz

library/pk.c

@@ -662,7 +662,8 @@ static int import_pair_into_psa(const mbedtls_pk_context *pk,
             if (ret < 0) {
                 return ret;
             }
-            size_t key_length = key_end - key_data;
+            size_t key_length;
+            key_length = (size_t) (key_end - key_data);
             ret = PSA_PK_TO_MBEDTLS_ERR(psa_import_key(attributes,
                                                        key_data, key_length,
                                                        key_id));

library/pkcs12.c

@@ -189,7 +189,7 @@ int mbedtls_pkcs12_pbe_ext(mbedtls_asn1_buf *pbe_params, int mode,
 
     iv_len = mbedtls_cipher_info_get_iv_size(cipher_info);
     if ((ret = pkcs12_pbe_derive_key_iv(pbe_params, md_type, pwd, pwdlen,
-                                        key, keylen,
+                                        key, (size_t) keylen,
                                         iv, iv_len)) != 0) {
         return ret;
     }

library/pkcs5.c

@@ -217,8 +217,8 @@ int mbedtls_pkcs5_pbes2_ext(const mbedtls_asn1_buf *pbe_params, int mode,
     memcpy(iv, enc_scheme_params.p, enc_scheme_params.len);
 
     if ((ret = mbedtls_pkcs5_pbkdf2_hmac_ext(md_type, pwd, pwdlen, salt.p,
-                                             salt.len, iterations, keylen,
-                                             key)) != 0) {
+                                             salt.len, (unsigned int) iterations,
+                                             (uint32_t) keylen, key)) != 0) {
         goto exit;
     }