[warnings] fix integer casting in winpr

* use WINPR_ASSERTING_INT_CAST to detect overflows in sign or narrow
  integer casts
* replace defines with static variables

winpr/include/winpr/bcrypt.h

@@ -33,66 +33,66 @@ typedef PVOID BCRYPT_KEY_HANDLE;
 typedef PVOID BCRYPT_HASH_HANDLE;
 typedef PVOID BCRYPT_SECRET_HANDLE;
 
-#define BCRYPT_RSA_ALGORITHM u"RSA"
-#define BCRYPT_RSA_SIGN_ALGORITHM u"RSA_SIGN"
-#define BCRYPT_DH_ALGORITHM u"DH"
-#define BCRYPT_DSA_ALGORITHM u"DSA"
-#define BCRYPT_RC2_ALGORITHM u"RC2"
-#define BCRYPT_RC4_ALGORITHM u"RC4"
-#define BCRYPT_AES_ALGORITHM u"AES"
-#define BCRYPT_DES_ALGORITHM u"DES"
-#define BCRYPT_DESX_ALGORITHM u"DESX"
-#define BCRYPT_3DES_ALGORITHM u"3DES"
-#define BCRYPT_3DES_112_ALGORITHM u"3DES_112"
-#define BCRYPT_MD2_ALGORITHM u"MD2"
-#define BCRYPT_MD4_ALGORITHM u"MD4"
-#define BCRYPT_MD5_ALGORITHM u"MD5"
-#define BCRYPT_SHA1_ALGORITHM u"SHA1"
-#define BCRYPT_SHA256_ALGORITHM u"SHA256"
-#define BCRYPT_SHA384_ALGORITHM u"SHA384"
-#define BCRYPT_SHA512_ALGORITHM u"SHA512"
-#define BCRYPT_AES_GMAC_ALGORITHM u"AES-GMAC"
-#define BCRYPT_AES_CMAC_ALGORITHM u"AES-CMAC"
-#define BCRYPT_ECDSA_P256_ALGORITHM u"ECDSA_P256"
-#define BCRYPT_ECDSA_P384_ALGORITHM u"ECDSA_P384"
-#define BCRYPT_ECDSA_P521_ALGORITHM u"ECDSA_P521"
-#define BCRYPT_ECDH_P256_ALGORITHM u"ECDSA_P256"
-#define BCRYPT_ECDH_P384_ALGORITHM u"ECDSA_P384"
-#define BCRYPT_ECDH_P521_ALGORITHM u"ECDSA_P521"
-#define BCRYPT_RNG_ALGORITHM u"RNG"
-#define BCRYPT_RNG_FIPS186_DSA_ALGORITHM u"FIPS186DSARNG"
-#define BCRYPT_RNG_DUAL_EC_ALGORITHM u"DUALECRNG"
+static const WCHAR BCRYPT_RSA_ALGORITHM[] = u"RSA";
+static const WCHAR BCRYPT_RSA_SIGN_ALGORITHM[] = u"RSA_SIGN";
+static const WCHAR BCRYPT_DH_ALGORITHM[] = u"DH";
+static const WCHAR BCRYPT_DSA_ALGORITHM[] = u"DSA";
+static const WCHAR BCRYPT_RC2_ALGORITHM[] = u"RC2";
+static const WCHAR BCRYPT_RC4_ALGORITHM[] = u"RC4";
+static const WCHAR BCRYPT_AES_ALGORITHM[] = u"AES";
+static const WCHAR BCRYPT_DES_ALGORITHM[] = u"DES";
+static const WCHAR BCRYPT_DESX_ALGORITHM[] = u"DESX";
+static const WCHAR BCRYPT_3DES_ALGORITHM[] = u"3DES";
+static const WCHAR BCRYPT_3DES_112_ALGORITHM[] = u"3DES_112";
+static const WCHAR BCRYPT_MD2_ALGORITHM[] = u"MD2";
+static const WCHAR BCRYPT_MD4_ALGORITHM[] = u"MD4";
+static const WCHAR BCRYPT_MD5_ALGORITHM[] = u"MD5";
+static const WCHAR BCRYPT_SHA1_ALGORITHM[] = u"SHA1";
+static const WCHAR BCRYPT_SHA256_ALGORITHM[] = u"SHA256";
+static const WCHAR BCRYPT_SHA384_ALGORITHM[] = u"SHA384";
+static const WCHAR BCRYPT_SHA512_ALGORITHM[] = u"SHA512";
+static const WCHAR BCRYPT_AES_GMAC_ALGORITHM[] = u"AES-GMAC";
+static const WCHAR BCRYPT_AES_CMAC_ALGORITHM[] = u"AES-CMAC";
+static const WCHAR BCRYPT_ECDSA_P256_ALGORITHM[] = u"ECDSA_P256";
+static const WCHAR BCRYPT_ECDSA_P384_ALGORITHM[] = u"ECDSA_P384";
+static const WCHAR BCRYPT_ECDSA_P521_ALGORITHM[] = u"ECDSA_P521";
+static const WCHAR BCRYPT_ECDH_P256_ALGORITHM[] = u"ECDSA_P256";
+static const WCHAR BCRYPT_ECDH_P384_ALGORITHM[] = u"ECDSA_P384";
+static const WCHAR BCRYPT_ECDH_P521_ALGORITHM[] = u"ECDSA_P521";
+static const WCHAR BCRYPT_RNG_ALGORITHM[] = u"RNG";
+static const WCHAR BCRYPT_RNG_FIPS186_DSA_ALGORITHM[] = u"FIPS186DSARNG";
+static const WCHAR BCRYPT_RNG_DUAL_EC_ALGORITHM[] = u"DUALECRNG";
 
-#define BCRYPT_ECDSA_ALGORITHM u"ECDSA"
-#define BCRYPT_ECDH_ALGORITHM u"ECDH"
-#define BCRYPT_XTS_AES_ALGORITHM u"XTS-AES"
+static const WCHAR BCRYPT_ECDSA_ALGORITHM[] = u"ECDSA";
+static const WCHAR BCRYPT_ECDH_ALGORITHM[] = u"ECDH";
+static const WCHAR BCRYPT_XTS_AES_ALGORITHM[] = u"XTS-AES";
 
-#define MS_PRIMITIVE_PROVIDER u"Microsoft Primitive Provider"
-#define MS_PLATFORM_CRYPTO_PROVIDER u"Microsoft Platform Crypto Provider"
+static const WCHAR MS_PRIMITIVE_PROVIDER[] = u"Microsoft Primitive Provider";
+static const WCHAR MS_PLATFORM_CRYPTO_PROVIDER[] = u"Microsoft Platform Crypto Provider";
 
 #define BCRYPT_ALG_HANDLE_HMAC_FLAG 0x00000008
 #define BCRYPT_PROV_DISPATCH 0x00000001
 
-#define BCRYPT_OBJECT_LENGTH u"ObjectLength"
-#define BCRYPT_ALGORITHM_NAME u"AlgorithmName"
-#define BCRYPT_PROVIDER_HANDLE u"ProviderHandle"
-#define BCRYPT_CHAINING_MODE u"ChainingMode"
-#define BCRYPT_BLOCK_LENGTH u"BlockLength"
-#define BCRYPT_KEY_LENGTH u"KeyLength"
-#define BCRYPT_KEY_OBJECT_LENGTH u"KeyObjectLength"
-#define BCRYPT_KEY_STRENGTH u"KeyStrength"
-#define BCRYPT_KEY_LENGTHS u"KeyLengths"
-#define BCRYPT_BLOCK_SIZE_LIST u"BlockSizeList"
-#define BCRYPT_EFFECTIVE_KEY_LENGTH u"EffectiveKeyLength"
-#define BCRYPT_HASH_LENGTH u"HashDigestLength"
-#define BCRYPT_HASH_OID_LIST u"HashOIDList"
-#define BCRYPT_PADDING_SCHEMES u"PaddingSchemes"
-#define BCRYPT_SIGNATURE_LENGTH u"SignatureLength"
-#define BCRYPT_HASH_BLOCK_LENGTH u"HashBlockLength"
-#define BCRYPT_AUTH_TAG_LENGTH u"AuthTagLength"
-#define BCRYPT_PRIMITIVE_TYPE u"PrimitiveType"
-#define BCRYPT_IS_KEYED_HASH u"IsKeyedHash"
-#define BCRYPT_KEY_DATA_BLOB u"KeyDataBlob"
+static const WCHAR BCRYPT_OBJECT_LENGTH[] = u"ObjectLength";
+static const WCHAR BCRYPT_ALGORITHM_NAME[] = u"AlgorithmName";
+static const WCHAR BCRYPT_PROVIDER_HANDLE[] = u"ProviderHandle";
+static const WCHAR BCRYPT_CHAINING_MODE[] = u"ChainingMode";
+static const WCHAR BCRYPT_BLOCK_LENGTH[] = u"BlockLength";
+static const WCHAR BCRYPT_KEY_LENGTH[] = u"KeyLength";
+static const WCHAR BCRYPT_KEY_OBJECT_LENGTH[] = u"KeyObjectLength";
+static const WCHAR BCRYPT_KEY_STRENGTH[] = u"KeyStrength";
+static const WCHAR BCRYPT_KEY_LENGTHS[] = u"KeyLengths";
+static const WCHAR BCRYPT_BLOCK_SIZE_LIST[] = u"BlockSizeList";
+static const WCHAR BCRYPT_EFFECTIVE_KEY_LENGTH[] = u"EffectiveKeyLength";
+static const WCHAR BCRYPT_HASH_LENGTH[] = u"HashDigestLength";
+static const WCHAR BCRYPT_HASH_OID_LIST[] = u"HashOIDList";
+static const WCHAR BCRYPT_PADDING_SCHEMES[] = u"PaddingSchemes";
+static const WCHAR BCRYPT_SIGNATURE_LENGTH[] = u"SignatureLength";
+static const WCHAR BCRYPT_HASH_BLOCK_LENGTH[] = u"HashBlockLength";
+static const WCHAR BCRYPT_AUTH_TAG_LENGTH[] = u"AuthTagLength";
+static const WCHAR BCRYPT_PRIMITIVE_TYPE[] = u"PrimitiveType";
+static const WCHAR BCRYPT_IS_KEYED_HASH[] = u"IsKeyedHash";
+static const WCHAR BCRYPT_KEY_DATA_BLOB[] = u"KeyDataBlob";
 
 #define BCRYPT_BLOCK_PADDING 0x00000001
 

winpr/include/winpr/error.h

@@ -2998,46 +2998,46 @@ WINPR_PRAGMA_DIAG_POP
 #define WS_E_SECURITY_SYSTEM_FAILURE 0x803D0023
 #endif
 
-#define NTE_BAD_UID INT32_C(0x80090001)
-#define NTE_BAD_HASH INT32_C(0x80090002)
-#define NTE_BAD_KEY INT32_C(0x80090003)
-#define NTE_BAD_LEN INT32_C(0x80090004)
-#define NTE_BAD_DATA INT32_C(0x80090005)
-#define NTE_BAD_SIGNATURE INT32_C(0x80090006)
-#define NTE_BAD_VER INT32_C(0x80090007)
-#define NTE_BAD_ALGID INT32_C(0x80090008)
-#define NTE_BAD_FLAGS INT32_C(0x80090009)
-#define NTE_BAD_TYPE INT32_C(0x8009000A)
-#define NTE_BAD_KEY_STATE INT32_C(0x8009000B)
-#define NTE_BAD_HASH_STATE INT32_C(0x8009000C)
-#define NTE_NO_KEY INT32_C(0x8009000D)
-#define NTE_NO_MEMORY INT32_C(0x8009000E)
-#define NTE_EXISTS INT32_C(0x8009000F)
-#define NTE_PERM INT32_C(0x80090010)
-#define NTE_NOT_FOUND INT32_C(0x80090011)
-#define NTE_DOUBLE_ENCRYPT INT32_C(0x80090012)
-#define NTE_BAD_PROVIDER INT32_C(0x80090013)
-#define NTE_BAD_PROV_TYPE INT32_C(0x80090014)
-#define NTE_BAD_PUBLIC_KEY INT32_C(0x80090015)
-#define NTE_BAD_KEYSET INT32_C(0x80090016)
-#define NTE_PROV_TYPE_NOT_DEF INT32_C(0x80090017)
-#define NTE_PROV_TYPE_ENTRY_BAD INT32_C(0x80090018)
-#define NTE_KEYSET_NOT_DEF INT32_C(0x80090019)
-#define NTE_KEYSET_ENTRY_BAD INT32_C(0x8009001A)
-#define NTE_PROV_TYPE_NO_MATCH INT32_C(0x8009001B)
-#define NTE_SIGNATURE_FILE_BAD INT32_C(0x8009001C)
-#define NTE_PROVIDER_DLL_FAIL INT32_C(0x8009001D)
-#define NTE_PROV_DLL_NOT_FOUND INT32_C(0x8009001E)
-#define NTE_BAD_KEYSET_PARAM INT32_C(0x8009001F)
-#define NTE_FAIL INT32_C(0x80090020)
-#define NTE_SYS_ERR INT32_C(0x80090021)
-#define NTE_SILENT_CONTEXT INT32_C(0x80090022)
-#define NTE_TOKEN_KEYSET_STORAGE_FULL INT32_C(0x80090023)
-#define NTE_TEMPORARY_PROFILE INT32_C(0x80090024)
-#define NTE_FIXEDPARAMETER INT32_C(0x80090025)
+#define NTE_BAD_UID WINPR_CXX_COMPAT_CAST(LONG, 0x80090001)
+#define NTE_BAD_HASH WINPR_CXX_COMPAT_CAST(LONG, 0x80090002)
+#define NTE_BAD_KEY WINPR_CXX_COMPAT_CAST(LONG, 0x80090003)
+#define NTE_BAD_LEN WINPR_CXX_COMPAT_CAST(LONG, 0x80090004)
+#define NTE_BAD_DATA WINPR_CXX_COMPAT_CAST(LONG, 0x80090005)
+#define NTE_BAD_SIGNATURE WINPR_CXX_COMPAT_CAST(LONG, 0x80090006)
+#define NTE_BAD_VER WINPR_CXX_COMPAT_CAST(LONG, 0x80090007)
+#define NTE_BAD_ALGID WINPR_CXX_COMPAT_CAST(LONG, 0x80090008)
+#define NTE_BAD_FLAGS WINPR_CXX_COMPAT_CAST(LONG, 0x80090009)
+#define NTE_BAD_TYPE WINPR_CXX_COMPAT_CAST(LONG, 0x8009000A)
+#define NTE_BAD_KEY_STATE WINPR_CXX_COMPAT_CAST(LONG, 0x8009000B)
+#define NTE_BAD_HASH_STATE WINPR_CXX_COMPAT_CAST(LONG, 0x8009000C)
+#define NTE_NO_KEY WINPR_CXX_COMPAT_CAST(LONG, 0x8009000D)
+#define NTE_NO_MEMORY WINPR_CXX_COMPAT_CAST(LONG, 0x8009000E)
+#define NTE_EXISTS WINPR_CXX_COMPAT_CAST(LONG, 0x8009000F)
+#define NTE_PERM WINPR_CXX_COMPAT_CAST(LONG, 0x80090010)
+#define NTE_NOT_FOUND WINPR_CXX_COMPAT_CAST(LONG, 0x80090011)
+#define NTE_DOUBLE_ENCRYPT WINPR_CXX_COMPAT_CAST(LONG, 0x80090012)
+#define NTE_BAD_PROVIDER WINPR_CXX_COMPAT_CAST(LONG, 0x80090013)
+#define NTE_BAD_PROV_TYPE WINPR_CXX_COMPAT_CAST(LONG, 0x80090014)
+#define NTE_BAD_PUBLIC_KEY WINPR_CXX_COMPAT_CAST(LONG, 0x80090015)
+#define NTE_BAD_KEYSET WINPR_CXX_COMPAT_CAST(LONG, 0x80090016)
+#define NTE_PROV_TYPE_NOT_DEF WINPR_CXX_COMPAT_CAST(LONG, 0x80090017)
+#define NTE_PROV_TYPE_ENTRY_BAD WINPR_CXX_COMPAT_CAST(LONG, 0x80090018)
+#define NTE_KEYSET_NOT_DEF WINPR_CXX_COMPAT_CAST(LONG, 0x80090019)
+#define NTE_KEYSET_ENTRY_BAD WINPR_CXX_COMPAT_CAST(LONG, 0x8009001A)
+#define NTE_PROV_TYPE_NO_MATCH WINPR_CXX_COMPAT_CAST(LONG, 0x8009001B)
+#define NTE_SIGNATURE_FILE_BAD WINPR_CXX_COMPAT_CAST(LONG, 0x8009001C)
+#define NTE_PROVIDER_DLL_FAIL WINPR_CXX_COMPAT_CAST(LONG, 0x8009001D)
+#define NTE_PROV_DLL_NOT_FOUND WINPR_CXX_COMPAT_CAST(LONG, 0x8009001E)
+#define NTE_BAD_KEYSET_PARAM WINPR_CXX_COMPAT_CAST(LONG, 0x8009001F)
+#define NTE_FAIL WINPR_CXX_COMPAT_CAST(LONG, 0x80090020)
+#define NTE_SYS_ERR WINPR_CXX_COMPAT_CAST(LONG, 0x80090021)
+#define NTE_SILENT_CONTEXT WINPR_CXX_COMPAT_CAST(LONG, 0x80090022)
+#define NTE_TOKEN_KEYSET_STORAGE_FULL WINPR_CXX_COMPAT_CAST(LONG, 0x80090023)
+#define NTE_TEMPORARY_PROFILE WINPR_CXX_COMPAT_CAST(LONG, 0x80090024)
+#define NTE_FIXEDPARAMETER WINPR_CXX_COMPAT_CAST(LONG, 0x80090025)
 #define NTE_NO_MORE_ITEMS ERROR_NO_MORE_ITEMS
 #define NTE_NOT_SUPPORTED ERROR_NOT_SUPPORTED
-#define NTE_INVALID_PARAMETER INT32_C(0x80090027)
+#define NTE_INVALID_PARAMETER WINPR_CXX_COMPAT_CAST(LONG, 0x80090027)
 
 #define EXCEPTION_MAXIMUM_PARAMETERS 15
 

winpr/include/winpr/sspi.h

@@ -22,6 +22,7 @@
 
 #include <winpr/platform.h>
 #include <winpr/winpr.h>
+#include <winpr/cast.h>
 #include <winpr/wtypes.h>
 #include <winpr/windows.h>
 #include <winpr/security.h>
@@ -128,125 +129,125 @@ typedef SecPkgInfoW* PSecPkgInfoW;
 
 #ifndef _WINERROR_
 
-#define SEC_E_OK (SECURITY_STATUS)0x00000000L
-#define SEC_E_INSUFFICIENT_MEMORY (SECURITY_STATUS)0x80090300L
-#define SEC_E_INVALID_HANDLE (SECURITY_STATUS)0x80090301L
-#define SEC_E_UNSUPPORTED_FUNCTION (SECURITY_STATUS)0x80090302L
-#define SEC_E_TARGET_UNKNOWN (SECURITY_STATUS)0x80090303L
-#define SEC_E_INTERNAL_ERROR (SECURITY_STATUS)0x80090304L
-#define SEC_E_SECPKG_NOT_FOUND (SECURITY_STATUS)0x80090305L
-#define SEC_E_NOT_OWNER (SECURITY_STATUS)0x80090306L
-#define SEC_E_CANNOT_INSTALL (SECURITY_STATUS)0x80090307L
-#define SEC_E_INVALID_TOKEN (SECURITY_STATUS)0x80090308L
-#define SEC_E_CANNOT_PACK (SECURITY_STATUS)0x80090309L
-#define SEC_E_QOP_NOT_SUPPORTED (SECURITY_STATUS)0x8009030AL
-#define SEC_E_NO_IMPERSONATION (SECURITY_STATUS)0x8009030BL
-#define SEC_E_LOGON_DENIED (SECURITY_STATUS)0x8009030CL
-#define SEC_E_UNKNOWN_CREDENTIALS (SECURITY_STATUS)0x8009030DL
-#define SEC_E_NO_CREDENTIALS (SECURITY_STATUS)0x8009030EL
-#define SEC_E_MESSAGE_ALTERED (SECURITY_STATUS)0x8009030FL
-#define SEC_E_OUT_OF_SEQUENCE (SECURITY_STATUS)0x80090310L
-#define SEC_E_NO_AUTHENTICATING_AUTHORITY (SECURITY_STATUS)0x80090311L
-#define SEC_E_BAD_PKGID (SECURITY_STATUS)0x80090316L
-#define SEC_E_CONTEXT_EXPIRED (SECURITY_STATUS)0x80090317L
-#define SEC_E_INCOMPLETE_MESSAGE (SECURITY_STATUS)0x80090318L
-#define SEC_E_INCOMPLETE_CREDENTIALS (SECURITY_STATUS)0x80090320L
-#define SEC_E_BUFFER_TOO_SMALL (SECURITY_STATUS)0x80090321L
-#define SEC_E_WRONG_PRINCIPAL (SECURITY_STATUS)0x80090322L
-#define SEC_E_TIME_SKEW (SECURITY_STATUS)0x80090324L
-#define SEC_E_UNTRUSTED_ROOT (SECURITY_STATUS)0x80090325L
-#define SEC_E_ILLEGAL_MESSAGE (SECURITY_STATUS)0x80090326L
-#define SEC_E_CERT_UNKNOWN (SECURITY_STATUS)0x80090327L
-#define SEC_E_CERT_EXPIRED (SECURITY_STATUS)0x80090328L
-#define SEC_E_ENCRYPT_FAILURE (SECURITY_STATUS)0x80090329L
-#define SEC_E_DECRYPT_FAILURE (SECURITY_STATUS)0x80090330L
-#define SEC_E_ALGORITHM_MISMATCH (SECURITY_STATUS)0x80090331L
-#define SEC_E_SECURITY_QOS_FAILED (SECURITY_STATUS)0x80090332L
-#define SEC_E_UNFINISHED_CONTEXT_DELETED (SECURITY_STATUS)0x80090333L
-#define SEC_E_NO_TGT_REPLY (SECURITY_STATUS)0x80090334L
-#define SEC_E_NO_IP_ADDRESSES (SECURITY_STATUS)0x80090335L
-#define SEC_E_WRONG_CREDENTIAL_HANDLE (SECURITY_STATUS)0x80090336L
-#define SEC_E_CRYPTO_SYSTEM_INVALID (SECURITY_STATUS)0x80090337L
-#define SEC_E_MAX_REFERRALS_EXCEEDED (SECURITY_STATUS)0x80090338L
-#define SEC_E_MUST_BE_KDC (SECURITY_STATUS)0x80090339L
-#define SEC_E_STRONG_CRYPTO_NOT_SUPPORTED (SECURITY_STATUS)0x8009033AL
-#define SEC_E_TOO_MANY_PRINCIPALS (SECURITY_STATUS)0x8009033BL
-#define SEC_E_NO_PA_DATA (SECURITY_STATUS)0x8009033CL
-#define SEC_E_PKINIT_NAME_MISMATCH (SECURITY_STATUS)0x8009033DL
-#define SEC_E_SMARTCARD_LOGON_REQUIRED (SECURITY_STATUS)0x8009033EL
-#define SEC_E_SHUTDOWN_IN_PROGRESS (SECURITY_STATUS)0x8009033FL
-#define SEC_E_KDC_INVALID_REQUEST (SECURITY_STATUS)0x80090340L
-#define SEC_E_KDC_UNABLE_TO_REFER (SECURITY_STATUS)0x80090341L
-#define SEC_E_KDC_UNKNOWN_ETYPE (SECURITY_STATUS)0x80090342L
-#define SEC_E_UNSUPPORTED_PREAUTH (SECURITY_STATUS)0x80090343L
-#define SEC_E_DELEGATION_REQUIRED (SECURITY_STATUS)0x80090345L
-#define SEC_E_BAD_BINDINGS (SECURITY_STATUS)0x80090346L
-#define SEC_E_MULTIPLE_ACCOUNTS (SECURITY_STATUS)0x80090347L
-#define SEC_E_NO_KERB_KEY (SECURITY_STATUS)0x80090348L
-#define SEC_E_CERT_WRONG_USAGE (SECURITY_STATUS)0x80090349L
-#define SEC_E_DOWNGRADE_DETECTED (SECURITY_STATUS)0x80090350L
-#define SEC_E_SMARTCARD_CERT_REVOKED (SECURITY_STATUS)0x80090351L
-#define SEC_E_ISSUING_CA_UNTRUSTED (SECURITY_STATUS)0x80090352L
-#define SEC_E_REVOCATION_OFFLINE_C (SECURITY_STATUS)0x80090353L
-#define SEC_E_PKINIT_CLIENT_FAILURE (SECURITY_STATUS)0x80090354L
-#define SEC_E_SMARTCARD_CERT_EXPIRED (SECURITY_STATUS)0x80090355L
-#define SEC_E_NO_S4U_PROT_SUPPORT (SECURITY_STATUS)0x80090356L
-#define SEC_E_CROSSREALM_DELEGATION_FAILURE (SECURITY_STATUS)0x80090357L
-#define SEC_E_REVOCATION_OFFLINE_KDC (SECURITY_STATUS)0x80090358L
-#define SEC_E_ISSUING_CA_UNTRUSTED_KDC (SECURITY_STATUS)0x80090359L
-#define SEC_E_KDC_CERT_EXPIRED (SECURITY_STATUS)0x8009035AL
-#define SEC_E_KDC_CERT_REVOKED (SECURITY_STATUS)0x8009035BL
-#define SEC_E_INVALID_PARAMETER (SECURITY_STATUS)0x8009035DL
-#define SEC_E_DELEGATION_POLICY (SECURITY_STATUS)0x8009035EL
-#define SEC_E_POLICY_NLTM_ONLY (SECURITY_STATUS)0x8009035FL
-#define SEC_E_NO_CONTEXT (SECURITY_STATUS)0x80090361L
-#define SEC_E_PKU2U_CERT_FAILURE (SECURITY_STATUS)0x80090362L
-#define SEC_E_MUTUAL_AUTH_FAILED (SECURITY_STATUS)0x80090363L
+#define SEC_E_OK WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00000000)
+#define SEC_E_INSUFFICIENT_MEMORY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090300)
+#define SEC_E_INVALID_HANDLE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090301)
+#define SEC_E_UNSUPPORTED_FUNCTION WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090302)
+#define SEC_E_TARGET_UNKNOWN WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090303)
+#define SEC_E_INTERNAL_ERROR WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090304)
+#define SEC_E_SECPKG_NOT_FOUND WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090305)
+#define SEC_E_NOT_OWNER WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090306)
+#define SEC_E_CANNOT_INSTALL WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090307)
+#define SEC_E_INVALID_TOKEN WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090308)
+#define SEC_E_CANNOT_PACK WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090309)
+#define SEC_E_QOP_NOT_SUPPORTED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009030A)
+#define SEC_E_NO_IMPERSONATION WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009030B)
+#define SEC_E_LOGON_DENIED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009030C)
+#define SEC_E_UNKNOWN_CREDENTIALS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009030D)
+#define SEC_E_NO_CREDENTIALS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009030E)
+#define SEC_E_MESSAGE_ALTERED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009030F)
+#define SEC_E_OUT_OF_SEQUENCE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090310)
+#define SEC_E_NO_AUTHENTICATING_AUTHORITY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090311)
+#define SEC_E_BAD_PKGID WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090316)
+#define SEC_E_CONTEXT_EXPIRED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090317)
+#define SEC_E_INCOMPLETE_MESSAGE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090318)
+#define SEC_E_INCOMPLETE_CREDENTIALS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090320)
+#define SEC_E_BUFFER_TOO_SMALL WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090321)
+#define SEC_E_WRONG_PRINCIPAL WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090322)
+#define SEC_E_TIME_SKEW WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090324)
+#define SEC_E_UNTRUSTED_ROOT WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090325)
+#define SEC_E_ILLEGAL_MESSAGE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090326)
+#define SEC_E_CERT_UNKNOWN WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090327)
+#define SEC_E_CERT_EXPIRED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090328)
+#define SEC_E_ENCRYPT_FAILURE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090329)
+#define SEC_E_DECRYPT_FAILURE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090330)
+#define SEC_E_ALGORITHM_MISMATCH WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090331)
+#define SEC_E_SECURITY_QOS_FAILED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090332)
+#define SEC_E_UNFINISHED_CONTEXT_DELETED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090333)
+#define SEC_E_NO_TGT_REPLY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090334)
+#define SEC_E_NO_IP_ADDRESSES WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090335)
+#define SEC_E_WRONG_CREDENTIAL_HANDLE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090336)
+#define SEC_E_CRYPTO_SYSTEM_INVALID WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090337)
+#define SEC_E_MAX_REFERRALS_EXCEEDED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090338)
+#define SEC_E_MUST_BE_KDC WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090339)
+#define SEC_E_STRONG_CRYPTO_NOT_SUPPORTED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009033A)
+#define SEC_E_TOO_MANY_PRINCIPALS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009033B)
+#define SEC_E_NO_PA_DATA WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009033C)
+#define SEC_E_PKINIT_NAME_MISMATCH WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009033D)
+#define SEC_E_SMARTCARD_LOGON_REQUIRED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009033E)
+#define SEC_E_SHUTDOWN_IN_PROGRESS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009033F)
+#define SEC_E_KDC_INVALID_REQUEST WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090340)
+#define SEC_E_KDC_UNABLE_TO_REFER WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090341)
+#define SEC_E_KDC_UNKNOWN_ETYPE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090342)
+#define SEC_E_UNSUPPORTED_PREAUTH WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090343)
+#define SEC_E_DELEGATION_REQUIRED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090345)
+#define SEC_E_BAD_BINDINGS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090346)
+#define SEC_E_MULTIPLE_ACCOUNTS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090347)
+#define SEC_E_NO_KERB_KEY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090348)
+#define SEC_E_CERT_WRONG_USAGE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090349)
+#define SEC_E_DOWNGRADE_DETECTED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090350)
+#define SEC_E_SMARTCARD_CERT_REVOKED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090351)
+#define SEC_E_ISSUING_CA_UNTRUSTED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090352)
+#define SEC_E_REVOCATION_OFFLINE_C WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090353)
+#define SEC_E_PKINIT_CLIENT_FAILURE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090354)
+#define SEC_E_SMARTCARD_CERT_EXPIRED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090355)
+#define SEC_E_NO_S4U_PROT_SUPPORT WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090356)
+#define SEC_E_CROSSREALM_DELEGATION_FAILURE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090357)
+#define SEC_E_REVOCATION_OFFLINE_KDC WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090358)
+#define SEC_E_ISSUING_CA_UNTRUSTED_KDC WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090359)
+#define SEC_E_KDC_CERT_EXPIRED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035A)
+#define SEC_E_KDC_CERT_REVOKED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035B)
+#define SEC_E_INVALID_PARAMETER WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035D)
+#define SEC_E_DELEGATION_POLICY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035E)
+#define SEC_E_POLICY_NLTM_ONLY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035F)
+#define SEC_E_NO_CONTEXT WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090361)
+#define SEC_E_PKU2U_CERT_FAILURE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090362)
+#define SEC_E_MUTUAL_AUTH_FAILED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090363)
 
-#define SEC_I_CONTINUE_NEEDED (SECURITY_STATUS)0x00090312L
-#define SEC_I_COMPLETE_NEEDED (SECURITY_STATUS)0x00090313L
-#define SEC_I_COMPLETE_AND_CONTINUE (SECURITY_STATUS)0x00090314L
-#define SEC_I_LOCAL_LOGON (SECURITY_STATUS)0x00090315L
-#define SEC_I_CONTEXT_EXPIRED (SECURITY_STATUS)0x00090317L
-#define SEC_I_INCOMPLETE_CREDENTIALS (SECURITY_STATUS)0x00090320L
-#define SEC_I_RENEGOTIATE (SECURITY_STATUS)0x00090321L
-#define SEC_I_NO_LSA_CONTEXT (SECURITY_STATUS)0x00090323L
-#define SEC_I_SIGNATURE_NEEDED (SECURITY_STATUS)0x0009035CL
-#define SEC_I_NO_RENEGOTIATION (SECURITY_STATUS)0x00090360L
+#define SEC_I_CONTINUE_NEEDED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090312)
+#define SEC_I_COMPLETE_NEEDED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090313)
+#define SEC_I_COMPLETE_AND_CONTINUE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090314)
+#define SEC_I_LOCAL_LOGON WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090315)
+#define SEC_I_CONTEXT_EXPIRED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090317)
+#define SEC_I_INCOMPLETE_CREDENTIALS WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090320)
+#define SEC_I_RENEGOTIATE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090321)
+#define SEC_I_NO_LSA_CONTEXT WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090323)
+#define SEC_I_SIGNATURE_NEEDED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x0009035C)
+#define SEC_I_NO_RENEGOTIATION WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090360)
 
 #endif /* _WINERROR_ */
 
 /* ============== some definitions missing in mingw ========================*/
 #ifndef SEC_E_INVALID_PARAMETER
-#define SEC_E_INVALID_PARAMETER (SECURITY_STATUS)0x8009035DL
+#define SEC_E_INVALID_PARAMETER WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035D)
 #endif
 
 #ifndef SEC_E_DELEGATION_POLICY
-#define SEC_E_DELEGATION_POLICY (SECURITY_STATUS)0x8009035EL
+#define SEC_E_DELEGATION_POLICY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035E)
 #endif
 
 #ifndef SEC_E_POLICY_NLTM_ONLY
-#define SEC_E_POLICY_NLTM_ONLY (SECURITY_STATUS)0x8009035FL
+#define SEC_E_POLICY_NLTM_ONLY WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x8009035F)
 #endif
 
 #ifndef SEC_E_NO_CONTEXT
-#define SEC_E_NO_CONTEXT (SECURITY_STATUS)0x80090361L
+#define SEC_E_NO_CONTEXT WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090361)
 #endif
 
 #ifndef SEC_E_PKU2U_CERT_FAILURE
-#define SEC_E_PKU2U_CERT_FAILURE (SECURITY_STATUS)0x80090362L
+#define SEC_E_PKU2U_CERT_FAILURE WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090362)
 #endif
 
 #ifndef SEC_E_MUTUAL_AUTH_FAILED
-#define SEC_E_MUTUAL_AUTH_FAILED (SECURITY_STATUS)0x80090363L
+#define SEC_E_MUTUAL_AUTH_FAILED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x80090363)
 #endif
 
 #ifndef SEC_I_SIGNATURE_NEEDED
-#define SEC_I_SIGNATURE_NEEDED (SECURITY_STATUS)0x0009035CL
+#define SEC_I_SIGNATURE_NEEDED WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x0009035C)
 #endif
 
 #ifndef SEC_I_NO_RENEGOTIATION
-#define SEC_I_NO_RENEGOTIATION (SECURITY_STATUS)0x00090360L
+#define SEC_I_NO_RENEGOTIATION WINPR_CXX_COMPAT_CAST(SECURITY_STATUS, 0x00090360)
 #endif
 
 /* ==================================================================================== */

winpr/libwinpr/clipboard/synthetic.c

@@ -500,7 +500,7 @@ static void* clipboard_synthesize_html_format(wClipboard* clipboard, UINT32 form
 
 	if (formatId == ClipboardGetFormatId(clipboard, "text/html"))
 	{
-		const INT64 SrcSize = (INT64)*pSize;
+		const size_t SrcSize = (size_t)*pSize;
 		const size_t DstSize = SrcSize + 200;
 		char* body = NULL;
 		char num[20] = { 0 };
@@ -605,7 +605,7 @@ static void* clipboard_synthesize_text_html(wClipboard* clipboard, UINT32 format
 	if (formatId == ClipboardGetFormatId(clipboard, "HTML Format"))
 	{
 		const char* str = (const char*)data;
-		const size_t SrcSize = (INT64)*pSize;
+		const size_t SrcSize = *pSize;
 		const char* begStr = strstr(str, "StartHTML:");
 		const char* endStr = strstr(str, "EndHTML:");
 

winpr/libwinpr/clipboard/synthetic_file.c

@@ -458,7 +458,7 @@ static BOOL process_uri_list(wClipboard* clipboard, const char* data, size_t len
 
 		if (stop == lim)
 		{
-			if (strnlen(start, stop - start) < 1)
+			if (strnlen(start, WINPR_ASSERTING_INT_CAST(size_t, stop - start)) < 1)
 				return TRUE;
 			cur = lim;
 		}
@@ -466,7 +466,7 @@ static BOOL process_uri_list(wClipboard* clipboard, const char* data, size_t len
 		if (comment)
 			continue;
 
-		if (!process_uri(clipboard, start, stop - start))
+		if (!process_uri(clipboard, start, WINPR_ASSERTING_INT_CAST(size_t, stop - start)))
 			return FALSE;
 	}
 
@@ -807,11 +807,13 @@ static void* convert_filedescriptors_to_file_list(wClipboard* clipboard, UINT32
 		previous_at = curName;
 		while ((stop_at = stop_at_special_chars(previous_at)) != NULL)
 		{
-			char* tmp = strndup(previous_at, stop_at - previous_at);
+			char* tmp =
+			    strndup(previous_at, WINPR_ASSERTING_INT_CAST(size_t, stop_at - previous_at));
 			if (!tmp)
 				goto loop_fail;
 
-			rc = _snprintf(&dst[pos], stop_at - previous_at + 1, "%s", tmp);
+			rc = _snprintf(&dst[pos], WINPR_ASSERTING_INT_CAST(size_t, stop_at - previous_at + 1),
+			               "%s", tmp);
 			free(tmp);
 			if (rc < 0)
 				goto loop_fail;
@@ -1012,7 +1014,7 @@ error:
 	return FALSE;
 }
 
-static UINT file_get_size(const struct synthetic_file* file, UINT64* size)
+static int32_t file_get_size(const struct synthetic_file* file, UINT64* size)
 {
 	UINT64 s = 0;
 
@@ -1148,8 +1150,9 @@ static UINT file_get_range(struct synthetic_file* file, UINT64 offset, UINT32 si
 
 			dwHigh = offset >> 32;
 			dwLow = offset & 0xFFFFFFFF;
-			if (INVALID_SET_FILE_POINTER ==
-			    SetFilePointer(file->fd, dwLow, (PLONG)&dwHigh, FILE_BEGIN))
+			if (INVALID_SET_FILE_POINTER == SetFilePointer(file->fd,
+			                                               WINPR_ASSERTING_INT_CAST(LONG, dwLow),
+			                                               (PLONG)&dwHigh, FILE_BEGIN))
 			{
 				error = GetLastError();
 				break;

winpr/libwinpr/comm/comm.c

@@ -722,7 +722,7 @@ BOOL SetCommState(HANDLE hFile, LPDCB lpDCB)
 
 	if (lpDCB->fBinary)
 	{
-		upcomingTermios.c_lflag &= ~ICANON;
+		upcomingTermios.c_lflag &= WINPR_ASSERTING_INT_CAST(tcflag_t, ~ICANON);
 	}
 	else
 	{
@@ -736,7 +736,7 @@ BOOL SetCommState(HANDLE hFile, LPDCB lpDCB)
 	}
 	else
 	{
-		upcomingTermios.c_iflag &= ~INPCK;
+		upcomingTermios.c_iflag &= WINPR_ASSERTING_INT_CAST(tcflag_t, ~INPCK);
 	}
 
 	/* http://msdn.microsoft.com/en-us/library/windows/desktop/aa363423%28v=vs.85%29.aspx
@@ -1400,8 +1400,8 @@ HANDLE CommCreateFileA(LPCSTR lpDeviceName, DWORD dwDesiredAccess, DWORD dwShare
 		goto error_handle;
 	}
 
-	upcomingTermios.c_iflag &=
-	    ~(/*IGNBRK |*/ BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL /*| IXON*/);
+	upcomingTermios.c_iflag &= WINPR_ASSERTING_INT_CAST(
+	    tcflag_t, ~(/*IGNBRK |*/ BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL /*| IXON*/));
 	upcomingTermios.c_oflag = 0; /* <=> &= ~OPOST */
 	upcomingTermios.c_lflag = 0; /* <=> &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); */
 	/* upcomingTermios.c_cflag &= ~(CSIZE | PARENB); */

winpr/libwinpr/comm/comm_io.c

@@ -335,12 +335,13 @@ BOOL CommReadFile(HANDLE hDevice, LPVOID lpBuffer, DWORD nNumberOfBytesToRead,
 			goto return_false;
 		}
 
-		*lpNumberOfBytesRead = (UINT32)nbRead;
+		*lpNumberOfBytesRead = WINPR_ASSERTING_INT_CAST(UINT32, nbRead);
 
 		EnterCriticalSection(&pComm->EventsLock);
 		if (pComm->PendingEvents & SERIAL_EV_WINPR_WAITING)
 		{
-			if (pComm->eventChar != '\0' && memchr(lpBuffer, pComm->eventChar, nbRead))
+			if (pComm->eventChar != '\0' &&
+			    memchr(lpBuffer, pComm->eventChar, WINPR_ASSERTING_INT_CAST(size_t, nbRead)))
 				pComm->PendingEvents |= SERIAL_EV_RXCHAR;
 		}
 		LeaveCriticalSection(&pComm->EventsLock);

winpr/libwinpr/comm/comm_serial_sys.c

@@ -438,7 +438,7 @@ static BOOL set_line_control(WINPR_COMM* pComm, const SERIAL_LINE_CONTROL* pLine
 	switch (pLineControl->StopBits)
 	{
 		case STOP_BIT_1:
-			upcomingTermios.c_cflag &= ~CSTOPB;
+			upcomingTermios.c_cflag &= (uint32_t)~CSTOPB;
 			break;
 
 		case STOP_BITS_1_5:
@@ -459,16 +459,16 @@ static BOOL set_line_control(WINPR_COMM* pComm, const SERIAL_LINE_CONTROL* pLine
 	switch (pLineControl->Parity)
 	{
 		case NO_PARITY:
-			upcomingTermios.c_cflag &= ~(PARENB | PARODD | CMSPAR);
+			upcomingTermios.c_cflag &= (uint32_t)~(PARENB | PARODD | CMSPAR);
 			break;
 
 		case ODD_PARITY:
-			upcomingTermios.c_cflag &= ~CMSPAR;
+			upcomingTermios.c_cflag &= (uint32_t)~CMSPAR;
 			upcomingTermios.c_cflag |= PARENB | PARODD;
 			break;
 
 		case EVEN_PARITY:
-			upcomingTermios.c_cflag &= ~(PARODD | CMSPAR);
+			upcomingTermios.c_cflag &= (uint32_t)~(PARODD | CMSPAR);
 			upcomingTermios.c_cflag |= PARENB;
 			break;
 
@@ -477,7 +477,7 @@ static BOOL set_line_control(WINPR_COMM* pComm, const SERIAL_LINE_CONTROL* pLine
 			break;
 
 		case SPACE_PARITY:
-			upcomingTermios.c_cflag &= ~PARODD;
+			upcomingTermios.c_cflag &= (uint32_t)~PARODD;
 			upcomingTermios.c_cflag |= PARENB | CMSPAR;
 			break;
 
@@ -491,22 +491,22 @@ static BOOL set_line_control(WINPR_COMM* pComm, const SERIAL_LINE_CONTROL* pLine
 	switch (pLineControl->WordLength)
 	{
 		case 5:
-			upcomingTermios.c_cflag &= ~CSIZE;
+			upcomingTermios.c_cflag &= (uint32_t)~CSIZE;
 			upcomingTermios.c_cflag |= CS5;
 			break;
 
 		case 6:
-			upcomingTermios.c_cflag &= ~CSIZE;
+			upcomingTermios.c_cflag &= (uint32_t)~CSIZE;
 			upcomingTermios.c_cflag |= CS6;
 			break;
 
 		case 7:
-			upcomingTermios.c_cflag &= ~CSIZE;
+			upcomingTermios.c_cflag &= (uint32_t)~CSIZE;
 			upcomingTermios.c_cflag |= CS7;
 			break;
 
 		case 8:
-			upcomingTermios.c_cflag &= ~CSIZE;
+			upcomingTermios.c_cflag &= (uint32_t)~CSIZE;
 			upcomingTermios.c_cflag |= CS8;
 			break;
 
@@ -611,7 +611,7 @@ static BOOL set_handflow(WINPR_COMM* pComm, const SERIAL_HANDFLOW* pHandflow)
 	}
 	else
 	{
-		upcomingTermios.c_cflag &= ~HUPCL;
+		upcomingTermios.c_cflag &= (uint32_t)~HUPCL;
 
 		/* FIXME: is the DTR line also needs to be forced to a disable state according
 		 * SERIAL_DTR_CONTROL? */
@@ -696,7 +696,7 @@ static BOOL set_handflow(WINPR_COMM* pComm, const SERIAL_HANDFLOW* pHandflow)
 	}
 	else
 	{
-		upcomingTermios.c_iflag &= ~IXON;
+		upcomingTermios.c_iflag &= (uint32_t)~IXON;
 	}
 
 	if (pHandflow->FlowReplace & SERIAL_AUTO_RECEIVE)
@@ -705,14 +705,14 @@ static BOOL set_handflow(WINPR_COMM* pComm, const SERIAL_HANDFLOW* pHandflow)
 	}
 	else
 	{
-		upcomingTermios.c_iflag &= ~IXOFF;
+		upcomingTermios.c_iflag &= (uint32_t)~IXOFF;
 	}
 
 	// FIXME: could be implemented during read/write I/O, as of today ErrorChar is necessary '\0'
 	if (pHandflow->FlowReplace & SERIAL_ERROR_CHAR)
 	{
 		/* errors will be replaced by the character '\0'. */
-		upcomingTermios.c_iflag &= ~IGNPAR;
+		upcomingTermios.c_iflag &= (uint32_t)~IGNPAR;
 	}
 	else
 	{
@@ -725,7 +725,7 @@ static BOOL set_handflow(WINPR_COMM* pComm, const SERIAL_HANDFLOW* pHandflow)
 	}
 	else
 	{
-		upcomingTermios.c_iflag &= ~IGNBRK;
+		upcomingTermios.c_iflag &= (uint32_t)~IGNBRK;
 	}
 
 	// FIXME: could be implemented during read/write I/O
@@ -1073,7 +1073,7 @@ static BOOL set_wait_mask(WINPR_COMM* pComm, const ULONG* pWaitMask)
 			Sleep(10); /* 10ms */
 
 		EnterCriticalSection(&pComm->EventsLock);
-		pComm->PendingEvents &= ~SERIAL_EV_WINPR_STOP;
+		pComm->PendingEvents &= (uint32_t)~SERIAL_EV_WINPR_STOP;
 		LeaveCriticalSection(&pComm->EventsLock);
 	}
 
@@ -1159,8 +1159,8 @@ static BOOL purge(WINPR_COMM* pComm, const ULONG* pPurgeMask)
 	WINPR_ASSERT(pComm);
 	WINPR_ASSERT(pPurgeMask);
 
-	if ((*pPurgeMask & ~(SERIAL_PURGE_TXABORT | SERIAL_PURGE_RXABORT | SERIAL_PURGE_TXCLEAR |
-	                     SERIAL_PURGE_RXCLEAR)) > 0)
+	if ((*pPurgeMask & (uint32_t)~(SERIAL_PURGE_TXABORT | SERIAL_PURGE_RXABORT |
+	                               SERIAL_PURGE_TXCLEAR | SERIAL_PURGE_RXCLEAR)) > 0)
 	{
 		CommLog_Print(WLOG_WARN, "Invalid purge mask: 0x%" PRIX32 "\n", *pPurgeMask);
 		SetLastError(ERROR_INVALID_PARAMETER);
@@ -1379,7 +1379,7 @@ static BOOL get_commstatus(WINPR_COMM* pComm, SERIAL_STATUS* pCommstatus)
 	{
 		/* FIXME: "now empty" from the specs is ambiguous, need to track previous completed
 		 * transmission? */
-		pComm->PendingEvents &= ~SERIAL_EV_TXEMPTY;
+		pComm->PendingEvents &= (uint32_t)~SERIAL_EV_TXEMPTY;
 	}
 
 	if (currentCounters.cts != pComm->counters.cts)
@@ -1413,7 +1413,7 @@ static BOOL get_commstatus(WINPR_COMM* pComm, SERIAL_STATUS* pCommstatus)
 	{
 		/* FIXME: "is 80 percent full" from the specs is ambiguous, need to track when it previously
 		 * * occurred? */
-		pComm->PendingEvents &= ~SERIAL_EV_RX80FULL;
+		pComm->PendingEvents &= (uint32_t)~SERIAL_EV_RX80FULL;
 	}
 
 	rc = TRUE;
@@ -1452,7 +1452,7 @@ static void consume_event(WINPR_COMM* pComm, ULONG* pOutputMask, ULONG event)
 static BOOL unlock_return(WINPR_COMM* pComm, BOOL res)
 {
 	EnterCriticalSection(&pComm->EventsLock);
-	pComm->PendingEvents &= ~SERIAL_EV_WINPR_WAITING;
+	pComm->PendingEvents &= (uint32_t)~SERIAL_EV_WINPR_WAITING;
 	LeaveCriticalSection(&pComm->EventsLock);
 	return res;
 }
@@ -1620,7 +1620,7 @@ static BOOL config_size(WINPR_COMM* pComm, ULONG* pSize)
 static BOOL immediate_char(WINPR_COMM* pComm, const UCHAR* pChar)
 {
 	BOOL result = 0;
-	DWORD nbBytesWritten = -1;
+	DWORD nbBytesWritten = 0;
 
 	WINPR_ASSERT(pComm);
 	WINPR_ASSERT(pChar);

winpr/libwinpr/crt/conversion.c

@@ -28,9 +28,7 @@
 
 errno_t _itoa_s(int value, char* buffer, size_t sizeInCharacters, int radix)
 {
-	int length = 0;
-
-	length = sprintf_s(NULL, 0, "%d", value);
+	int length = sprintf_s(NULL, 0, "%d", value);
 
 	if (length < 0)
 		return -1;
@@ -38,7 +36,7 @@ errno_t _itoa_s(int value, char* buffer, size_t sizeInCharacters, int radix)
 	if (sizeInCharacters < (size_t)length)
 		return -1;
 
-	(void)sprintf_s(buffer, length + 1, "%d", value);
+	(void)sprintf_s(buffer, WINPR_ASSERTING_INT_CAST(size_t, length + 1), "%d", value);
 
 	return 0;
 }

winpr/libwinpr/crt/test/TestUnicodeConversion.c

@@ -97,7 +97,8 @@ static BOOL compare_utf16_int(const WCHAR* what, size_t buffersize, SSIZE_T rc,
 	}
 	else
 	{
-		if (!check_short_buffer(prefix, rc, buffersize, test, FALSE))
+		if (!check_short_buffer(prefix, WINPR_ASSERTING_INT_CAST(SSIZE_T, rc), buffersize, test,
+		                        FALSE))
 			return FALSE;
 	}
 
@@ -151,7 +152,8 @@ static BOOL compare_utf8_int(const char* what, size_t buffersize, SSIZE_T rc, SS
 	}
 	else
 	{
-		if (!check_short_buffer(prefix, rc, buffersize, test, TRUE))
+		if (!check_short_buffer(prefix, WINPR_ASSERTING_INT_CAST(SSIZE_T, rc), buffersize, test,
+		                        TRUE))
 			return FALSE;
 	}
 
@@ -220,7 +222,8 @@ static BOOL test_convert_to_utf16_n(const testcase_t* test)
 	if ((rc2 < 0) || ((size_t)rc2 != wlen))
 	{
 		char prefix[8192] = { 0 };
-		create_prefix(prefix, ARRAYSIZE(prefix), 0, rc2, test->utf8len, test, __func__, __LINE__);
+		create_prefix(prefix, ARRAYSIZE(prefix), 0, rc2,
+		              WINPR_ASSERTING_INT_CAST(SSIZE_T, test->utf8len), test, __func__, __LINE__);
 		(void)fprintf(stderr,
 		              "%s ConvertUtf8NToWChar(%s, %" PRIuz ", NULL, 0) expected %" PRIuz
 		              ", got %" PRIdz "\n",
@@ -285,7 +288,8 @@ static BOOL test_convert_to_utf8_n(const testcase_t* test)
 	if ((rc2 < 0) || ((size_t)rc2 != wlen))
 	{
 		char prefix[8192] = { 0 };
-		create_prefix(prefix, ARRAYSIZE(prefix), 0, rc2, test->utf16len, test, __func__, __LINE__);
+		create_prefix(prefix, ARRAYSIZE(prefix), 0, rc2,
+		              WINPR_ASSERTING_INT_CAST(SSIZE_T, test->utf16len), test, __func__, __LINE__);
 		(void)fprintf(stderr,
 		              "%s ConvertWCharNToUtf8(%s, %" PRIuz ", NULL, 0) expected %" PRIuz
 		              ", got %" PRIdz "\n",

winpr/libwinpr/crt/unicode_builtin.c

@@ -41,6 +41,7 @@ See the header file "utf.h" for complete documentation.
 #include <winpr/wtypes.h>
 #include <winpr/string.h>
 #include <winpr/assert.h>
+#include <winpr/cast.h>
 
 #include "unicode.h"
 
@@ -392,7 +393,8 @@ static ConversionResult winpr_ConvertUTF8toUTF16_Internal(const uint8_t** source
 	while (source < sourceEnd)
 	{
 		uint32_t ch = 0;
-		unsigned short extraBytesToRead = trailingBytesForUTF8[*source];
+		unsigned short extraBytesToRead =
+		    WINPR_ASSERTING_INT_CAST(unsigned short, trailingBytesForUTF8[*source]);
 
 		if ((source + extraBytesToRead) >= sourceEnd)
 		{
@@ -572,7 +574,7 @@ static int winpr_ConvertUTF8toUTF16(const uint8_t* src, int cchSrc, uint16_t* ds
 		return 0;
 	}
 
-	return (result == conversionOK) ? length : 0;
+	return (result == conversionOK) ? WINPR_ASSERTING_INT_CAST(int, length) : 0;
 }
 
 static int winpr_ConvertUTF16toUTF8(const uint16_t* src, int cchSrc, uint8_t* dst, int cchDst)
@@ -614,7 +616,7 @@ static int winpr_ConvertUTF16toUTF8(const uint16_t* src, int cchSrc, uint8_t* ds
 		return 0;
 	}
 
-	return (result == conversionOK) ? length : 0;
+	return (result == conversionOK) ? WINPR_ASSERTING_INT_CAST(int, length) : 0;
 }
 
 /* --------------------------------------------------------------------- */
@@ -655,7 +657,8 @@ int int_MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr,
 			return 0;
 	}
 
-	return winpr_ConvertUTF8toUTF16((const uint8_t*)lpMultiByteStr, cbCharLen,
+	return winpr_ConvertUTF8toUTF16((const uint8_t*)lpMultiByteStr,
+	                                WINPR_ASSERTING_INT_CAST(int, cbCharLen),
 	                                (uint16_t*)lpWideCharStr, cchWideChar);
 }
 
@@ -690,6 +693,7 @@ int int_WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr,
 	 * in bytes for lpMultiByteStr and makes no use of the output parameter itself.
 	 */
 
-	return winpr_ConvertUTF16toUTF8((const uint16_t*)lpWideCharStr, cbCharLen,
+	return winpr_ConvertUTF16toUTF8((const uint16_t*)lpWideCharStr,
+	                                WINPR_ASSERTING_INT_CAST(int, cbCharLen),
 	                                (uint8_t*)lpMultiByteStr, cbMultiByte);
 }

winpr/libwinpr/crt/unicode_icu.c

@@ -62,14 +62,14 @@ int int_MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr,
 	if (isNullTerminated)
 		len = strlen(lpMultiByteStr) + 1;
 	else
-		len = cbMultiByte;
+		len = WINPR_ASSERTING_INT_CAST(size_t, cbMultiByte);
 
 	if (len >= INT_MAX)
 	{
 		SetLastError(ERROR_INVALID_PARAMETER);
 		return 0;
 	}
-	cbMultiByte = (int)len;
+	cbMultiByte = WINPR_ASSERTING_INT_CAST(int, len);
 
 	/*
 	 * if cchWideChar is 0, the function returns the required buffer size
@@ -161,14 +161,14 @@ int int_WideCharToMultiByte(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr,
 	if (cchWideChar == -1)
 		len = _wcslen(lpWideCharStr) + 1;
 	else
-		len = cchWideChar;
+		len = WINPR_ASSERTING_INT_CAST(size_t, cchWideChar);
 
 	if (len >= INT32_MAX)
 	{
 		SetLastError(ERROR_INVALID_PARAMETER);
 		return 0;
 	}
-	cchWideChar = (int)len;
+	cchWideChar = WINPR_ASSERTING_INT_CAST(int, len);
 
 	/*
 	 * if cbMultiByte is 0, the function returns the required buffer size

winpr/libwinpr/crypto/cipher.c

@@ -778,7 +778,7 @@ int winpr_Cipher_BytesToKey(int cipher, WINPR_MD_TYPE md, const void* salt, cons
 	const EVP_MD* evp_md = NULL;
 	const EVP_CIPHER* evp_cipher = NULL;
 	evp_md = winpr_openssl_get_evp_md(md);
-	evp_cipher = winpr_openssl_get_evp_cipher(cipher);
+	evp_cipher = winpr_openssl_get_evp_cipher(WINPR_ASSERTING_INT_CAST(WINPR_CIPHER_TYPE, cipher));
 	WINPR_ASSERT(datal <= INT_MAX);
 	WINPR_ASSERT(count <= INT_MAX);
 	return EVP_BytesToKey(evp_cipher, evp_md, salt, data, (int)datal, (int)count, key, iv);

winpr/libwinpr/crypto/hash.c

@@ -548,6 +548,7 @@ BOOL winpr_Digest_Init_Allow_FIPS(WINPR_DIGEST_CTX* ctx, WINPR_MD_TYPE md)
 
 #if defined(WITH_OPENSSL)
 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
+#if !defined(WITH_INTERNAL_MD5)
 	if (md == WINPR_MD_MD5)
 	{
 		EVP_MD* md5 = EVP_MD_fetch(NULL, "MD5", "fips=no");
@@ -555,6 +556,7 @@ BOOL winpr_Digest_Init_Allow_FIPS(WINPR_DIGEST_CTX* ctx, WINPR_MD_TYPE md)
 		EVP_MD_free(md5);
 		return rc;
 	}
+#endif
 #endif
 	const EVP_MD* evp = winpr_openssl_get_evp_md(md);
 	EVP_MD_CTX_set_flags(ctx->mdctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);

winpr/libwinpr/crypto/rc4.c

@@ -18,6 +18,7 @@
  * limitations under the License.
  */
 #include <winpr/assert.h>
+#include <winpr/cast.h>
 
 #include "rc4.h"
 
@@ -46,7 +47,7 @@ winpr_int_RC4_CTX* winpr_int_rc4_new(const BYTE* key, size_t keylength)
 
 	for (size_t i = 0; i < CTX_SIZE; i++)
 	{
-		ctx->s[i] = i;
+		ctx->s[i] = WINPR_ASSERTING_INT_CAST(BYTE, i);
 		ctx->t[i] = key[i % keylength];
 	}
 

winpr/libwinpr/environment/environment.c

@@ -422,7 +422,8 @@ LPCH MergeEnvironmentStrings(PCSTR original, PCSTR merge)
 			if (!foundEquals)
 				continue;
 
-			if (strncmp(envp, mergeStrings[run], foundEquals - mergeStrings[run] + 1) == 0)
+			const intptr_t len = foundEquals - mergeStrings[run] + 1;
+			if (strncmp(envp, mergeStrings[run], WINPR_ASSERTING_INT_CAST(size_t, len)) == 0)
 			{
 				// found variable in merge list ... use this ....
 				if (*(foundEquals + 1) == '\0')
@@ -534,7 +535,7 @@ DWORD GetEnvironmentVariableEBA(LPCSTR envBlock, LPCSTR lpName, LPSTR lpBuffer,
 			return 0;
 		}
 
-		nLength = (foundEquals - penvb);
+		nLength = WINPR_ASSERTING_INT_CAST(size_t, (foundEquals - penvb));
 
 		if (nLength != lpNameLength)
 		{

winpr/libwinpr/file/file.c

@@ -963,7 +963,7 @@ static HANDLE FileCreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dw
 
 	if (fstat(fileno(pFile->fp), &st) == 0 && dwFlagsAndAttributes & FILE_ATTRIBUTE_READONLY)
 	{
-		st.st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
+		st.st_mode &= WINPR_ASSERTING_INT_CAST(mode_t, ~(S_IWUSR | S_IWGRP | S_IWOTH));
 		fchmod(fileno(pFile->fp), st.st_mode);
 	}
 

winpr/libwinpr/file/generic.c

@@ -630,7 +630,7 @@ BOOL SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes)
 
 	if (dwFileAttributes & FILE_ATTRIBUTE_READONLY)
 	{
-		st.st_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
+		st.st_mode &= WINPR_ASSERTING_INT_CAST(mode_t, (mode_t)(~(S_IWUSR | S_IWGRP | S_IWOTH)));
 	}
 	else
 	{

winpr/libwinpr/file/pattern.c

@@ -326,9 +326,9 @@ BOOL FilePatternMatchA(LPCSTR lpFileName, LPCSTR lpPattern)
 		if (!lpNextWildcard)
 		{
 			lpX = lpSubPattern;
-			cchX = (lpWildcard - lpSubPattern);
+			cchX = WINPR_ASSERTING_INT_CAST(size_t, (lpWildcard - lpSubPattern));
 			lpY = &lpSubPattern[cchX + cchWildcard];
-			cchY = (cchSubPattern - (lpY - lpSubPattern));
+			cchY = (cchSubPattern - WINPR_ASSERTING_INT_CAST(size_t, (lpY - lpSubPattern)));
 			match = FilePatternMatchSubExpressionA(lpSubFileName, cchSubFileName, lpX, cchX, lpY,
 			                                       cchY, lpWildcard, &lpMatchEnd);
 			return match;
@@ -337,12 +337,14 @@ BOOL FilePatternMatchA(LPCSTR lpFileName, LPCSTR lpPattern)
 		{
 			while (lpNextWildcard)
 			{
-				cchSubFileName = cchFileName - (lpSubFileName - lpFileName);
+				cchSubFileName =
+				    cchFileName - WINPR_ASSERTING_INT_CAST(size_t, (lpSubFileName - lpFileName));
 				cchNextWildcard = ((dwNextFlags & WILDCARD_DOS) ? 2 : 1);
 				lpX = lpSubPattern;
-				cchX = (lpWildcard - lpSubPattern);
+				cchX = WINPR_ASSERTING_INT_CAST(size_t, (lpWildcard - lpSubPattern));
 				lpY = &lpSubPattern[cchX + cchWildcard];
-				cchY = (lpNextWildcard - lpWildcard) - cchWildcard;
+				cchY =
+				    WINPR_ASSERTING_INT_CAST(size_t, (lpNextWildcard - lpWildcard)) - cchWildcard;
 				match = FilePatternMatchSubExpressionA(lpSubFileName, cchSubFileName, lpX, cchX,
 				                                       lpY, cchY, lpWildcard, &lpMatchEnd);
 

winpr/libwinpr/ncrypt/ncrypt_pkcs11.c

@@ -579,11 +579,11 @@ static void wprintKeyName(LPWSTR str, CK_SLOT_ID slotId, CK_BYTE* id, CK_ULONG i
 
 static size_t parseHex(const char* str, const char* end, CK_BYTE* target)
 {
-	int ret = 0;
+	size_t ret = 0;
 
 	for (; str != end && *str; str++, ret++, target++)
 	{
-		CK_BYTE v = 0;
+		int v = 0;
 		if (*str <= '9' && *str >= '0')
 		{
 			v = (*str - '0');
@@ -623,7 +623,7 @@ static size_t parseHex(const char* str, const char* end, CK_BYTE* target)
 			return 0;
 		}
 
-		*target = v;
+		*target = v & 0xFF;
 	}
 	return ret;
 }

winpr/libwinpr/path/shell.c

@@ -390,7 +390,8 @@ char* GetKnownPath(eKnownPathTypes id)
 	}
 
 	if (!path)
-		WLog_WARN(TAG, "Path %s is %p", GetKnownPathIdString(id), path);
+		WLog_WARN(TAG, "Path %s is %p", GetKnownPathIdString(WINPR_ASSERTING_INT_CAST(int, id)),
+		          path);
 	return path;
 }
 

winpr/libwinpr/registry/registry_reg.c

@@ -227,20 +227,17 @@ static RegVal* reg_load_value(const Reg* reg, RegKey* key)
 		break;
 		case REG_SZ:
 		{
-			size_t len = 0;
-			size_t cmp = 0;
-			char* end = NULL;
 			char* start = strchr(data, '"');
 			if (!start)
 				goto fail;
 
 			/* Check for terminating quote, check it is the last symbol */
-			len = strlen(start);
-			end = strchr(start + 1, '"');
+			const size_t len = strlen(start);
+			char* end = strchr(start + 1, '"');
 			if (!end)
 				goto fail;
-			cmp = end - start + 1;
-			if (len != cmp)
+			const intptr_t cmp = end - start + 1;
+			if ((cmp < 0) || (len != WINPR_ASSERTING_INT_CAST(size_t, cmp)))
 				goto fail;
 			if (start[0] == '"')
 				start++;

winpr/libwinpr/rpc/rpc.c

@@ -732,12 +732,13 @@ RPC_STATUS UuidToStringW(const UUID* Uuid, RPC_WSTR* StringUuid)
 
 RPC_STATUS UuidFromStringA(RPC_CSTR StringUuid, UUID* Uuid)
 {
-	BYTE bin[36];
+	BYTE bin[36] = { 0 };
 
 	if (!StringUuid)
 		return UuidCreateNil(Uuid);
 
-	if (strlen((char*)StringUuid) != 36)
+	const size_t slen = 2 * sizeof(UUID) + 4;
+	if (strnlen(StringUuid, slen) != slen)
 		return RPC_S_INVALID_STRING_UUID;
 
 	if ((StringUuid[8] != '-') || (StringUuid[13] != '-') || (StringUuid[18] != '-') ||
@@ -746,17 +747,17 @@ RPC_STATUS UuidFromStringA(RPC_CSTR StringUuid, UUID* Uuid)
 		return RPC_S_INVALID_STRING_UUID;
 	}
 
-	for (int index = 0; index < 36; index++)
+	for (size_t index = 0; index < 36; index++)
 	{
 		if ((index == 8) || (index == 13) || (index == 18) || (index == 23))
 			continue;
 
 		if ((StringUuid[index] >= '0') && (StringUuid[index] <= '9'))
-			bin[index] = StringUuid[index] - '0';
+			bin[index] = (StringUuid[index] - '0') & 0xFF;
 		else if ((StringUuid[index] >= 'a') && (StringUuid[index] <= 'f'))
-			bin[index] = StringUuid[index] - 'a' + 10;
+			bin[index] = (StringUuid[index] - 'a' + 10) & 0xFF;
 		else if ((StringUuid[index] >= 'A') && (StringUuid[index] <= 'F'))
-			bin[index] = StringUuid[index] - 'A' + 10;
+			bin[index] = (StringUuid[index] - 'A' + 10) & 0xFF;
 		else
 			return RPC_S_INVALID_STRING_UUID;
 	}

winpr/libwinpr/shell/shell.c

@@ -18,7 +18,7 @@
  */
 
 #include <winpr/config.h>
-
+#include <winpr/cast.h>
 #include <winpr/shell.h>
 
 /**
@@ -68,7 +68,8 @@ BOOL GetUserProfileDirectoryA(HANDLE hToken, LPSTR lpProfileDir, LPDWORD lpcchSi
 	if (!buf)
 		return FALSE;
 
-	const int status = getpwnam_r(token->Username, &pwd, buf, buflen, &pw);
+	const int status =
+	    getpwnam_r(token->Username, &pwd, buf, WINPR_ASSERTING_INT_CAST(size_t, buflen), &pw);
 
 	if ((status != 0) || !pw)
 	{

winpr/libwinpr/sspi/Kerberos/kerberos.c

@@ -29,6 +29,7 @@
 #include <ctype.h>
 
 #include <winpr/assert.h>
+#include <winpr/cast.h>
 #include <winpr/asn1.h>
 #include <winpr/crt.h>
 #include <winpr/interlocked.h>
@@ -126,6 +127,9 @@ static const WinPrAsn1_OID kerberos_OID = { 9, (void*)"\x2a\x86\x48\x86\xf7\x12\
 static const WinPrAsn1_OID kerberos_u2u_OID = { 10,
 	                                            (void*)"\x2a\x86\x48\x86\xf7\x12\x01\x02\x02\x03" };
 
+#define krb_log_exec_bool(fkt, ctx, ...)                                                     \
+	kerberos_log_msg(ctx, fkt(ctx, ##__VA_ARGS__) ? KRB5KRB_ERR_GENERIC : 0, #fkt, __FILE__, \
+	                 __func__, __LINE__)
 #define krb_log_exec(fkt, ctx, ...) \
 	kerberos_log_msg(ctx, fkt(ctx, ##__VA_ARGS__), #fkt, __FILE__, __func__, __LINE__)
 #define krb_log_exec_ptr(fkt, ctx, ...) \
@@ -405,7 +409,7 @@ static SECURITY_STATUS SEC_ENTRY kerberos_AcquireCredentialsHandleA(
 	{
 		krb5_creds creds = { 0 };
 		krb5_creds matchCreds = { 0 };
-		int matchFlags = KRB5_TC_MATCH_TIMES;
+		krb5_flags matchFlags = KRB5_TC_MATCH_TIMES;
 
 		krb5_timeofday(ctx, &matchCreds.times.endtime);
 		matchCreds.times.endtime += 60;
@@ -1348,10 +1352,10 @@ static SECURITY_STATUS SEC_ENTRY kerberos_AcceptSecurityContext(
 			if (rv != 0)
 				goto cleanup;
 
-			if ((!sname || krb_log_exec(krb5_principal_compare_any_realm, credentials->ctx,
-			                            principal, entry.principal)) &&
-			    (!realm ||
-			     krb_log_exec(krb5_realm_compare, credentials->ctx, principal, entry.principal)))
+			if ((!sname || krb_log_exec_bool(krb5_principal_compare_any_realm, credentials->ctx,
+			                                 principal, entry.principal)) &&
+			    (!realm || krb_log_exec_bool(krb5_realm_compare, credentials->ctx, principal,
+			                                 entry.principal)))
 				break;
 			if (krb_log_exec(krb5glue_free_keytab_entry_contents, credentials->ctx, &entry))
 				goto cleanup;
@@ -1597,7 +1601,7 @@ static SECURITY_STATUS kerberos_ATTR_TICKET_LOGON(KRB_CONTEXT* context,
 {
 	krb5_creds matchCred = { 0 };
 	krb5_auth_context authContext = NULL;
-	int getCredsFlags = KRB5_GC_CACHED;
+	krb5_flags getCredsFlags = KRB5_GC_CACHED;
 	BOOL firstRun = TRUE;
 	krb5_creds* hostCred = NULL;
 	SECURITY_STATUS ret = SEC_E_INSUFFICIENT_MEMORY;
@@ -1866,7 +1870,7 @@ static SECURITY_STATUS SEC_ENTRY kerberos_EncryptMessage(PCtxtHandle phContext,
 
 	/* Write the GSS header with 0 in RRC */
 	winpr_Data_Write_UINT16_BE(header, TOK_ID_WRAP);
-	header[2] = flags;
+	header[2] = WINPR_ASSERTING_INT_CAST(char, flags);
 	header[3] = (char)0xFF;
 	winpr_Data_Write_UINT32(header + 4, 0);
 	winpr_Data_Write_UINT64_BE(header + 8, (context->local_seq + MessageSeqNo));
@@ -1875,8 +1879,8 @@ static SECURITY_STATUS SEC_ENTRY kerberos_EncryptMessage(PCtxtHandle phContext,
 	CopyMemory(encrypt_iov[2].data.data, header, 16);
 
 	/* Set the correct RRC */
-	winpr_Data_Write_UINT16_BE(header + 6,
-	                           16 + encrypt_iov[3].data.length + encrypt_iov[4].data.length);
+	const size_t len = 16 + encrypt_iov[3].data.length + encrypt_iov[4].data.length;
+	winpr_Data_Write_UINT16_BE(header + 6, WINPR_ASSERTING_INT_CAST(UINT16, len));
 
 	if (krb_log_exec(krb5glue_encrypt_iov, creds->ctx, key, usage, encrypt_iov,
 	                 ARRAYSIZE(encrypt_iov)))
@@ -1898,7 +1902,6 @@ static SECURITY_STATUS SEC_ENTRY kerberos_DecryptMessage(PCtxtHandle phContext,
 	PSecBuffer data_buffer = NULL;
 	krb5glue_key key = NULL;
 	krb5_keyusage usage = 0;
-	char* header = NULL;
 	uint16_t tok_id = 0;
 	BYTE flags = 0;
 	uint16_t ec = 0;
@@ -1925,15 +1928,15 @@ static SECURITY_STATUS SEC_ENTRY kerberos_DecryptMessage(PCtxtHandle phContext,
 		return SEC_E_INVALID_TOKEN;
 
 	/* Read in header information */
-	header = sig_buffer->pvBuffer;
+	BYTE* header = sig_buffer->pvBuffer;
 	tok_id = winpr_Data_Get_UINT16_BE(header);
 	flags = header[2];
-	ec = winpr_Data_Get_UINT16_BE((header + 4));
-	rrc = winpr_Data_Get_UINT16_BE((header + 6));
-	seq_no = winpr_Data_Get_UINT64_BE((header + 8));
+	ec = winpr_Data_Get_UINT16_BE(&header[4]);
+	rrc = winpr_Data_Get_UINT16_BE(&header[6]);
+	seq_no = winpr_Data_Get_UINT64_BE(&header[8]);
 
 	/* Check that the header is valid */
-	if (tok_id != TOK_ID_WRAP || (BYTE)header[3] != 0xFF)
+	if ((tok_id != TOK_ID_WRAP) || (header[3] != 0xFF))
 		return SEC_E_INVALID_TOKEN;
 
 	if ((flags & FLAG_SENDER_IS_ACCEPTOR) == context->acceptor)
@@ -1969,11 +1972,15 @@ static SECURITY_STATUS SEC_ENTRY kerberos_DecryptMessage(PCtxtHandle phContext,
 		return SEC_E_INVALID_TOKEN;
 
 	/* Locate the parts of the message */
-	iov[0].data.data = header + 16 + rrc + ec;
+	iov[0].data.data = (char*)&header[16 + rrc + ec];
 	iov[1].data.data = data_buffer->pvBuffer;
-	iov[2].data.data = header + 16 + ec;
-	iov[3].data.data = iov[2].data.data + iov[2].data.length;
-	iov[4].data.data = iov[3].data.data + iov[3].data.length;
+	iov[2].data.data = (char*)&header[16 + ec];
+	char* data2 = iov[2].data.data;
+	iov[3].data.data = &data2[iov[2].data.length];
+
+	char* data3 = iov[3].data.data;
+	iov[4].data.data = &data2[iov[3].data.length];
+	iov[4].data.data = &data3[iov[3].data.length];
 
 	if (krb_log_exec(krb5glue_decrypt_iov, creds->ctx, key, usage, iov, ARRAYSIZE(iov)))
 		return SEC_E_INTERNAL_ERROR;
@@ -2001,7 +2008,6 @@ static SECURITY_STATUS SEC_ENTRY kerberos_MakeSignature(PCtxtHandle phContext, U
 	PSecBuffer data_buffer = NULL;
 	krb5glue_key key = NULL;
 	krb5_keyusage usage = 0;
-	char* header = NULL;
 	BYTE flags = 0;
 	krb5_crypto_iov iov[] = { { KRB5_CRYPTO_TYPE_DATA, { 0 } },
 		                      { KRB5_CRYPTO_TYPE_DATA, { 0 } },
@@ -2041,9 +2047,9 @@ static SECURITY_STATUS SEC_ENTRY kerberos_MakeSignature(PCtxtHandle phContext, U
 		return SEC_E_INSUFFICIENT_MEMORY;
 
 	/* Write the header */
-	header = sig_buffer->pvBuffer;
+	char* header = sig_buffer->pvBuffer;
 	winpr_Data_Write_UINT16_BE(header, TOK_ID_MIC);
-	header[2] = flags;
+	header[2] = WINPR_ASSERTING_INT_CAST(char, flags);
 	memset(header + 3, 0xFF, 5);
 	winpr_Data_Write_UINT64_BE(header + 8, (context->local_seq + MessageSeqNo));
 
@@ -2072,7 +2078,6 @@ static SECURITY_STATUS SEC_ENTRY kerberos_VerifySignature(PCtxtHandle phContext,
 	PSecBuffer data_buffer = NULL;
 	krb5glue_key key = NULL;
 	krb5_keyusage usage = 0;
-	char* header = NULL;
 	BYTE flags = 0;
 	uint16_t tok_id = 0;
 	uint64_t seq_no = 0;
@@ -2096,7 +2101,7 @@ static SECURITY_STATUS SEC_ENTRY kerberos_VerifySignature(PCtxtHandle phContext,
 		return SEC_E_INVALID_TOKEN;
 
 	/* Read in header info */
-	header = sig_buffer->pvBuffer;
+	BYTE* header = sig_buffer->pvBuffer;
 	tok_id = winpr_Data_Get_UINT16_BE(header);
 	flags = header[2];
 	seq_no = winpr_Data_Get_UINT64_BE((header + 8));
@@ -2132,8 +2137,8 @@ static SECURITY_STATUS SEC_ENTRY kerberos_VerifySignature(PCtxtHandle phContext,
 
 	/* Set up the iov array */
 	iov[0].data.data = data_buffer->pvBuffer;
-	iov[1].data.data = header;
-	iov[2].data.data = header + 16;
+	iov[1].data.data = (char*)header;
+	iov[2].data.data = (char*)&header[16];
 
 	if (krb_log_exec(krb5glue_verify_checksum_iov, creds->ctx, key, usage, iov, ARRAYSIZE(iov),
 	                 &is_valid))

winpr/libwinpr/sspi/NTLM/ntlm_av_pairs.c

@@ -133,7 +133,8 @@ ULONG ntlm_av_pair_list_length(NTLM_AV_PAIR* pAvPairList, size_t cbAvPairList)
 	if (pAvPair < pAvPairList)
 		return 0;
 
-	const size_t size = ((PBYTE)pAvPair - (PBYTE)pAvPairList) + sizeof(NTLM_AV_PAIR);
+	const size_t size = WINPR_ASSERTING_INT_CAST(size_t, ((PBYTE)pAvPair - (PBYTE)pAvPairList)) +
+	                    sizeof(NTLM_AV_PAIR);
 	WINPR_ASSERT(size <= UINT32_MAX);
 	WINPR_ASSERT(size >= 0);
 	return (ULONG)size;

winpr/libwinpr/sspi/Schannel/schannel_openssl.c

@@ -155,7 +155,7 @@ int schannel_openssl_client_init(SCHANNEL_OPENSSL* context)
 	 * support empty fragments. This needs to be disabled.
 	 */
 	options |= SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS;
-	SSL_CTX_set_options(context->ctx, options);
+	SSL_CTX_set_options(context->ctx, WINPR_ASSERTING_INT_CAST(uint64_t, options));
 	context->ssl = SSL_new(context->ctx);
 
 	if (!context->ssl)
@@ -411,11 +411,12 @@ SECURITY_STATUS schannel_openssl_client_process_tokens(SCHANNEL_OPENSSL* context
 
 		if (status > 0)
 		{
-			if (pBuffer->cbBuffer < (unsigned long)status)
+			if (pBuffer->cbBuffer < WINPR_ASSERTING_INT_CAST(uint32_t, status))
 				return SEC_E_INSUFFICIENT_MEMORY;
 
-			CopyMemory(pBuffer->pvBuffer, context->ReadBuffer, status);
-			pBuffer->cbBuffer = status;
+			CopyMemory(pBuffer->pvBuffer, context->ReadBuffer,
+			           WINPR_ASSERTING_INT_CAST(uint32_t, status));
+			pBuffer->cbBuffer = WINPR_ASSERTING_INT_CAST(uint32_t, status);
 			return (context->connected) ? SEC_E_OK : SEC_I_CONTINUE_NEEDED;
 		}
 		else
@@ -480,11 +481,12 @@ SECURITY_STATUS schannel_openssl_server_process_tokens(SCHANNEL_OPENSSL* context
 
 		if (status > 0)
 		{
-			if (pBuffer->cbBuffer < (unsigned long)status)
+			if (pBuffer->cbBuffer < WINPR_ASSERTING_INT_CAST(uint32_t, status))
 				return SEC_E_INSUFFICIENT_MEMORY;
 
-			CopyMemory(pBuffer->pvBuffer, context->ReadBuffer, status);
-			pBuffer->cbBuffer = status;
+			CopyMemory(pBuffer->pvBuffer, context->ReadBuffer,
+			           WINPR_ASSERTING_INT_CAST(uint32_t, status));
+			pBuffer->cbBuffer = WINPR_ASSERTING_INT_CAST(uint32_t, status);
 			return (context->connected) ? SEC_E_OK : SEC_I_CONTINUE_NEEDED;
 		}
 		else
@@ -575,7 +577,7 @@ SECURITY_STATUS schannel_openssl_decrypt_message(SCHANNEL_OPENSSL* context, PSec
 	pMessage->pBuffers[0].cbBuffer = 5;
 	pMessage->pBuffers[1].BufferType = SECBUFFER_DATA;
 	pMessage->pBuffers[1].pvBuffer = buffer;
-	pMessage->pBuffers[1].cbBuffer = length;
+	pMessage->pBuffers[1].cbBuffer = WINPR_ASSERTING_INT_CAST(uint32_t, length);
 	pMessage->pBuffers[2].BufferType = SECBUFFER_STREAM_TRAILER;
 	pMessage->pBuffers[2].cbBuffer = 36;
 	pMessage->pBuffers[3].BufferType = SECBUFFER_EMPTY;

winpr/libwinpr/sspi/sspi.c

@@ -457,7 +457,7 @@ const char* GetSecurityStatusString(SECURITY_STATUS status)
 			break;
 	}
 
-	return NtStatus2Tag((DWORD)status);
+	return NtStatus2Tag(status);
 }
 
 BOOL IsSecurityStatusError(SECURITY_STATUS status)

winpr/libwinpr/sspi/sspi_gss.c

@@ -111,7 +111,7 @@ BOOL sspi_gss_unwrap_token(const SecBuffer* buf, WinPrAsn1_OID* oid, uint16_t* t
 		return FALSE;
 
 	if (tok_id)
-		Stream_Read_INT16_BE(s, *tok_id);
+		Stream_Read_UINT16_BE(s, *tok_id);
 
 	token->data = Stream_Pointer(s);
 	token->length = (UINT)Stream_GetRemainingLength(s);

winpr/libwinpr/sspi/sspi_winpr.c

@@ -357,7 +357,7 @@ int sspi_SetAuthIdentityWithLengthW(SEC_WINNT_AUTH_IDENTITY* identity, const WCH
 {
 	WINPR_ASSERT(identity);
 	sspi_FreeAuthIdentity(identity);
-	identity->Flags &= ~SEC_WINNT_AUTH_IDENTITY_ANSI;
+	identity->Flags &= (uint32_t)~SEC_WINNT_AUTH_IDENTITY_ANSI;
 	identity->Flags |= SEC_WINNT_AUTH_IDENTITY_UNICODE;
 
 	if (!copy(&identity->User, &identity->UserLength, user, userLen))
@@ -882,7 +882,7 @@ int sspi_CopyAuthIdentity(SEC_WINNT_AUTH_IDENTITY* identity,
 		if (status <= 0)
 			return -1;
 
-		identity->Flags &= ~SEC_WINNT_AUTH_IDENTITY_ANSI;
+		identity->Flags &= (uint32_t)~SEC_WINNT_AUTH_IDENTITY_ANSI;
 		identity->Flags |= SEC_WINNT_AUTH_IDENTITY_UNICODE;
 		return 1;
 	}

winpr/libwinpr/sspicli/sspicli.c

@@ -163,7 +163,8 @@ BOOL LogonUserA(LPCSTR lpszUsername, LPCSTR lpszDomain, LPCSTR lpszPassword, DWO
 
 	struct passwd pwd = { 0 };
 	struct passwd* pw = NULL;
-	const int rc = getpwnam_r(lpszUsername, &pwd, buf, buflen, &pw);
+	const int rc =
+	    getpwnam_r(lpszUsername, &pwd, buf, WINPR_ASSERTING_INT_CAST(size_t, buflen), &pw);
 	free(buf);
 	if ((rc == 0) && pw)
 	{

winpr/libwinpr/sysinfo/sysinfo.c

@@ -447,7 +447,7 @@ BOOL GetComputerNameA(LPSTR lpBuffer, LPDWORD lpnSize)
 	size_t length = strnlen(hostname, MAX_COMPUTERNAME_LENGTH);
 	const char* dot = strchr(hostname, '.');
 	if (dot)
-		length = (dot - hostname);
+		length = WINPR_ASSERTING_INT_CAST(size_t, (dot - hostname));
 
 	if ((*lpnSize <= (DWORD)length) || !lpBuffer)
 	{
@@ -577,7 +577,8 @@ UINT64 winpr_GetTickCount64NS(void)
 	struct timespec ts = { 0 };
 
 	if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts) == 0)
-		ticks = (ts.tv_sec * 1000000000ull) + ts.tv_nsec;
+		ticks = (WINPR_ASSERTING_INT_CAST(uint64_t, ts.tv_sec) * 1000000000ull) +
+		        WINPR_ASSERTING_INT_CAST(uint64_t, ts.tv_nsec);
 #elif defined(__MACH__) && defined(__APPLE__)
 	ticks = mac_get_time_ns();
 #elif defined(_WIN32)
@@ -630,7 +631,8 @@ UINT64 winpr_GetUnixTimeNS(void)
 	struct timespec ts = { 0 };
 	if (clock_gettime(CLOCK_REALTIME, &ts) != 0)
 		return 0;
-	return ts.tv_sec * 1000000000ull + ts.tv_nsec;
+	return WINPR_ASSERTING_INT_CAST(uint64_t, ts.tv_sec) * 1000000000ull +
+	       WINPR_ASSERTING_INT_CAST(uint64_t, ts.tv_nsec);
 #else
 	struct timeval tv = { 0 };
 	if (gettimeofday(&tv, NULL) != 0)

winpr/libwinpr/thread/argv.c

@@ -157,8 +157,8 @@ LPSTR* CommandLineToArgvA(LPCSTR lpCmdLine, int* pNumArgs)
 				pBeg--;
 			}
 
-			n = ((pEnd - pBeg) - 1);
-			length = (pBeg - pLastEnd);
+			n = WINPR_ASSERTING_INT_CAST(size_t, ((pEnd - pBeg) - 1));
+			length = WINPR_ASSERTING_INT_CAST(size_t, (pBeg - pLastEnd));
 			CopyMemory(pOutput, p, length);
 			pOutput += length;
 			p += length;
@@ -221,7 +221,7 @@ LPSTR* CommandLineToArgvA(LPCSTR lpCmdLine, int* pNumArgs)
 		if (*p != '"')
 		{
 			/* no whitespace escaped with double quotes */
-			length = (p - pBeg);
+			length = WINPR_ASSERTING_INT_CAST(size_t, (p - pBeg));
 			CopyMemory(pOutput, pBeg, length);
 			pOutput[length] = '\0';
 			pArgs[numArgs++] = pOutput;

winpr/libwinpr/utils/asn1/asn1.c

@@ -1168,13 +1168,13 @@ static int read2digits(wStream* s)
 	int ret = 0;
 	char c = 0;
 
-	Stream_Read_UINT8(s, c);
+	Stream_Read_INT8(s, c);
 	if (c < '0' || c > '9')
 		return -1;
 
 	ret = (c - '0') * 10;
 
-	Stream_Read_UINT8(s, c);
+	Stream_Read_INT8(s, c);
 	if (c < '0' || c > '9')
 		return -1;
 
@@ -1203,38 +1203,38 @@ size_t WinPrAsn1DecReadUtcTime(WinPrAsn1Decoder* dec, WinPrAsn1_UTCTIME* target)
 	Stream_StaticConstInit(s, Stream_ConstPointer(&dec->source), len);
 
 	v = read2digits(s);
-	if (v <= 0)
+	if ((v <= 0) || (v >= UINT16_MAX - 2000))
 		return 0;
-	target->year = 2000 + v;
+	target->year = (UINT16)(2000 + v);
 
 	v = read2digits(s);
-	if (v <= 0)
+	if ((v <= 0) || (v > UINT8_MAX))
 		return 0;
-	target->month = v;
+	target->month = (UINT8)v;
 
 	v = read2digits(s);
-	if (v <= 0)
+	if ((v <= 0) || (v > UINT8_MAX))
 		return 0;
-	target->day = v;
+	target->day = (UINT8)v;
 
 	v = read2digits(s);
-	if (v <= 0)
+	if ((v <= 0) || (v > UINT8_MAX))
 		return 0;
-	target->hour = v;
+	target->hour = (UINT8)v;
 
 	v = read2digits(s);
-	if (v <= 0)
+	if ((v <= 0) || (v > UINT8_MAX))
 		return 0;
-	target->minute = v;
+	target->minute = (UINT8)v;
 
 	v = read2digits(s);
-	if (v <= 0)
+	if ((v <= 0) || (v > UINT8_MAX))
 		return 0;
-	target->second = v;
+	target->second = (UINT8)v;
 
 	if (Stream_GetRemainingLength(s) >= 1)
 	{
-		Stream_Read_UINT8(s, target->tz);
+		Stream_Read_INT8(s, target->tz);
 	}
 
 	Stream_Seek(&dec->source, len);

winpr/libwinpr/utils/cmdline.c

@@ -196,7 +196,7 @@ int CommandLineParseArgumentsA(int argc, LPSTR* argv, COMMAND_LINE_ARGUMENT_A* o
 			{
 				SSIZE_T separator_index = (separator - argv[i]);
 				SSIZE_T value_index = separator_index + 1;
-				keyword_length = (separator - keyword);
+				keyword_length = WINPR_ASSERTING_INT_CAST(size_t, (separator - keyword));
 				value = &argv[i][value_index];
 			}
 			else
@@ -818,7 +818,7 @@ char* CommandLineToCommaSeparatedValuesEx(int argc, char* argv[], const char* fi
 {
 	char* str = NULL;
 	size_t offset = 0;
-	size_t size = argc + 1;
+	size_t size = WINPR_ASSERTING_INT_CAST(size_t, argc) + 1;
 	if ((argc <= 0) || !argv)
 		return NULL;
 

winpr/libwinpr/utils/collections/ArrayList.c

@@ -236,15 +236,16 @@ static BOOL ArrayList_Shift(wArrayList* arrayList, size_t index, SSIZE_T count)
 	}
 	else if (count < 0)
 	{
-		const size_t off = index + (size_t)(-1 * count);
+		const size_t scount = WINPR_ASSERTING_INT_CAST(size_t, -count);
+		const size_t off = index + scount;
 		if (off < arrayList->size)
 		{
 			const size_t chunk = arrayList->size - off;
-			MoveMemory((void*)&arrayList->array[index], (void*)&arrayList->array[index - count],
+			MoveMemory((void*)&arrayList->array[index], (void*)&arrayList->array[off],
 			           chunk * sizeof(void*));
 		}
 
-		arrayList->size += count;
+		arrayList->size -= scount;
 	}
 
 	return TRUE;

winpr/libwinpr/utils/collections/BufferPool.c

@@ -23,6 +23,8 @@
 
 #include <winpr/collections.h>
 
+#define MAX(a, b) ((a) > (b)) ? (a) : (b)
+
 typedef struct
 {
 	SSIZE_T size;
@@ -85,28 +87,35 @@ static BOOL BufferPool_ShiftAvailable(wBufferPool* pool, size_t index, int count
 		if (pool->aSize + count > pool->aCapacity)
 		{
 			wBufferPoolItem* newArray = NULL;
-			SSIZE_T newCapacity = pool->aCapacity * 2;
+			SSIZE_T newCapacity = pool->aSize + count;
+			newCapacity += (newCapacity + 2) / 2;
 
+			WINPR_ASSERT(newCapacity > 0);
 			if (pool->alignment > 0)
 				newArray = (wBufferPoolItem*)winpr_aligned_realloc(
-				    pool->aArray, sizeof(wBufferPoolItem) * newCapacity, pool->alignment);
+				    pool->aArray,
+				    sizeof(wBufferPoolItem) * WINPR_ASSERTING_INT_CAST(size_t, newCapacity),
+				    pool->alignment);
 			else
-				newArray =
-				    (wBufferPoolItem*)realloc(pool->aArray, sizeof(wBufferPoolItem) * newCapacity);
+				newArray = (wBufferPoolItem*)realloc(
+				    pool->aArray,
+				    sizeof(wBufferPoolItem) * WINPR_ASSERTING_INT_CAST(size_t, newCapacity));
 			if (!newArray)
 				return FALSE;
 			pool->aArray = newArray;
 			pool->aCapacity = newCapacity;
 		}
 
-		MoveMemory(&pool->aArray[index + count], &pool->aArray[index],
-		           (pool->aSize - index) * sizeof(wBufferPoolItem));
+		MoveMemory(
+		    &pool->aArray[index + WINPR_ASSERTING_INT_CAST(size_t, count)], &pool->aArray[index],
+		    (WINPR_ASSERTING_INT_CAST(size_t, pool->aSize) - index) * sizeof(wBufferPoolItem));
 		pool->aSize += count;
 	}
 	else if (count < 0)
 	{
-		MoveMemory(&pool->aArray[index], &pool->aArray[index - count],
-		           (pool->aSize - index) * sizeof(wBufferPoolItem));
+		MoveMemory(
+		    &pool->aArray[index], &pool->aArray[index + WINPR_ASSERTING_INT_CAST(size_t, -count)],
+		    (WINPR_ASSERTING_INT_CAST(size_t, pool->aSize) - index) * sizeof(wBufferPoolItem));
 		pool->aSize += count;
 	}
 	return TRUE;
@@ -122,10 +131,13 @@ static BOOL BufferPool_ShiftUsed(wBufferPool* pool, SSIZE_T index, SSIZE_T count
 			wBufferPoolItem* newUArray = NULL;
 			if (pool->alignment > 0)
 				newUArray = (wBufferPoolItem*)winpr_aligned_realloc(
-				    pool->uArray, sizeof(wBufferPoolItem) * newUCapacity, pool->alignment);
+				    pool->uArray,
+				    sizeof(wBufferPoolItem) * WINPR_ASSERTING_INT_CAST(size_t, newUCapacity),
+				    pool->alignment);
 			else
-				newUArray =
-				    (wBufferPoolItem*)realloc(pool->uArray, sizeof(wBufferPoolItem) * newUCapacity);
+				newUArray = (wBufferPoolItem*)realloc(
+				    pool->uArray,
+				    sizeof(wBufferPoolItem) * WINPR_ASSERTING_INT_CAST(size_t, newUCapacity));
 			if (!newUArray)
 				return FALSE;
 			pool->uCapacity = newUCapacity;
@@ -133,13 +145,13 @@ static BOOL BufferPool_ShiftUsed(wBufferPool* pool, SSIZE_T index, SSIZE_T count
 		}
 
 		MoveMemory(&pool->uArray[index + count], &pool->uArray[index],
-		           (pool->uSize - index) * sizeof(wBufferPoolItem));
+		           WINPR_ASSERTING_INT_CAST(size_t, pool->uSize - index) * sizeof(wBufferPoolItem));
 		pool->uSize += count;
 	}
 	else if (count < 0)
 	{
 		MoveMemory(&pool->uArray[index], &pool->uArray[index - count],
-		           (pool->uSize - index) * sizeof(wBufferPoolItem));
+		           WINPR_ASSERTING_INT_CAST(size_t, pool->uSize - index) * sizeof(wBufferPoolItem));
 		pool->uSize += count;
 	}
 	return TRUE;
@@ -232,9 +244,10 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
 		if (!buffer)
 		{
 			if (pool->alignment)
-				buffer = winpr_aligned_malloc(pool->fixedSize, pool->alignment);
+				buffer = winpr_aligned_malloc(WINPR_ASSERTING_INT_CAST(size_t, pool->fixedSize),
+				                              pool->alignment);
 			else
-				buffer = malloc(pool->fixedSize);
+				buffer = malloc(WINPR_ASSERTING_INT_CAST(size_t, pool->fixedSize));
 		}
 
 		if (!buffer)
@@ -279,9 +292,10 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
 			else
 			{
 				if (pool->alignment)
-					buffer = winpr_aligned_malloc(size, pool->alignment);
+					buffer = winpr_aligned_malloc(WINPR_ASSERTING_INT_CAST(size_t, size),
+					                              pool->alignment);
 				else
-					buffer = malloc(size);
+					buffer = malloc(WINPR_ASSERTING_INT_CAST(size_t, size));
 
 				if (!buffer)
 					goto out_error;
@@ -295,9 +309,10 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
 			{
 				void* newBuffer = NULL;
 				if (pool->alignment)
-					newBuffer = winpr_aligned_realloc(buffer, size, pool->alignment);
+					newBuffer = winpr_aligned_realloc(
+					    buffer, WINPR_ASSERTING_INT_CAST(size_t, size), pool->alignment);
 				else
-					newBuffer = realloc(buffer, size);
+					newBuffer = realloc(buffer, WINPR_ASSERTING_INT_CAST(size_t, size));
 
 				if (!newBuffer)
 					goto out_error_no_free;
@@ -305,7 +320,7 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
 				buffer = newBuffer;
 			}
 
-			if (!BufferPool_ShiftAvailable(pool, foundIndex, -1))
+			if (!BufferPool_ShiftAvailable(pool, WINPR_ASSERTING_INT_CAST(size_t, foundIndex), -1))
 				goto out_error;
 		}
 
@@ -314,7 +329,8 @@ void* BufferPool_Take(wBufferPool* pool, SSIZE_T size)
 
 		if (pool->uSize + 1 > pool->uCapacity)
 		{
-			size_t newUCapacity = pool->uCapacity * 2ULL;
+			size_t newUCapacity = WINPR_ASSERTING_INT_CAST(size_t, pool->uCapacity);
+			newUCapacity += (newUCapacity + 2) / 2;
 			if (newUCapacity > SSIZE_MAX)
 				goto out_error;
 			wBufferPoolItem* newUArray =
@@ -363,8 +379,9 @@ BOOL BufferPool_Return(wBufferPool* pool, void* buffer)
 
 		if ((pool->size + 1) >= pool->capacity)
 		{
-			SSIZE_T newCapacity = pool->capacity * 2;
-			void** newArray = (void**)realloc((void*)pool->array, sizeof(void*) * newCapacity);
+			SSIZE_T newCapacity = MAX(1, pool->size + (pool->size + 2) / 2 + 1);
+			void** newArray = (void**)realloc(
+			    (void*)pool->array, sizeof(void*) * WINPR_ASSERTING_INT_CAST(size_t, newCapacity));
 			if (!newArray)
 				goto out_error;
 
@@ -399,9 +416,10 @@ BOOL BufferPool_Return(wBufferPool* pool, void* buffer)
 		{
 			if ((pool->aSize + 1) >= pool->aCapacity)
 			{
-				SSIZE_T newCapacity = pool->aCapacity * 2;
-				wBufferPoolItem* newArray =
-				    (wBufferPoolItem*)realloc(pool->aArray, sizeof(wBufferPoolItem) * newCapacity);
+				SSIZE_T newCapacity = MAX(1, pool->aSize + (pool->aSize + 2) / 2 + 1);
+				wBufferPoolItem* newArray = (wBufferPoolItem*)realloc(
+				    pool->aArray,
+				    sizeof(wBufferPoolItem) * WINPR_ASSERTING_INT_CAST(size_t, newCapacity));
 				if (!newArray)
 					goto out_error;
 
@@ -500,7 +518,8 @@ wBufferPool* BufferPool_New(BOOL synchronized, SSIZE_T fixedSize, DWORD alignmen
 
 			pool->size = 0;
 			pool->capacity = 32;
-			pool->array = (void**)calloc(pool->capacity, sizeof(void*));
+			pool->array =
+			    (void**)calloc(WINPR_ASSERTING_INT_CAST(size_t, pool->capacity), sizeof(void*));
 			if (!pool->array)
 				goto out_error;
 		}
@@ -510,13 +529,15 @@ wBufferPool* BufferPool_New(BOOL synchronized, SSIZE_T fixedSize, DWORD alignmen
 
 			pool->aSize = 0;
 			pool->aCapacity = 32;
-			pool->aArray = (wBufferPoolItem*)calloc(pool->aCapacity, sizeof(wBufferPoolItem));
+			pool->aArray = (wBufferPoolItem*)calloc(
+			    WINPR_ASSERTING_INT_CAST(size_t, pool->aCapacity), sizeof(wBufferPoolItem));
 			if (!pool->aArray)
 				goto out_error;
 
 			pool->uSize = 0;
 			pool->uCapacity = 32;
-			pool->uArray = (wBufferPoolItem*)calloc(pool->uCapacity, sizeof(wBufferPoolItem));
+			pool->uArray = (wBufferPoolItem*)calloc(
+			    WINPR_ASSERTING_INT_CAST(size_t, pool->uCapacity), sizeof(wBufferPoolItem));
 			if (!pool->uArray)
 				goto out_error;
 		}

winpr/libwinpr/utils/collections/ListDictionary.c

@@ -159,7 +159,7 @@ size_t ListDictionary_GetKeys(wListDictionary* listDictionary, ULONG_PTR** ppKey
 			if (listDictionary->synchronized)
 				LeaveCriticalSection(&listDictionary->lock);
 
-			return -1;
+			return 0;
 		}
 	}
 

winpr/libwinpr/utils/image.c

@@ -165,8 +165,9 @@ BOOL readBitmapInfoHeader(wStream* s, WINPR_BITMAP_INFO_HEADER* bi, size_t* poff
 			}
 			if (bi->biSizeImage == 0)
 			{
-				UINT32 stride = ((((bi->biWidth * bi->biBitCount) + 31) & ~31) >> 3);
-				bi->biSizeImage = abs(bi->biHeight) * stride;
+				UINT32 stride = WINPR_ASSERTING_INT_CAST(
+				    uint32_t, ((((bi->biWidth * bi->biBitCount) + 31) & ~31) >> 3));
+				bi->biSizeImage = WINPR_ASSERTING_INT_CAST(uint32_t, abs(bi->biHeight)) * stride;
 			}
 			break;
 		case BI_BITFIELDS:
@@ -323,7 +324,7 @@ int winpr_bitmap_write_ex(const char* filename, const BYTE* data, size_t stride,
 	FILE* fp = NULL;
 	int ret = -1;
 	void* bmpdata = NULL;
-	const size_t bpp_stride = ((((width * bpp) + 31) & ~31) >> 3);
+	const size_t bpp_stride = ((((width * bpp) + 31) & (size_t)~31) >> 3);
 
 	if ((stride > UINT32_MAX) || (width > UINT32_MAX) || (height > UINT32_MAX) ||
 	    (bpp > UINT32_MAX))
@@ -379,7 +380,7 @@ fail:
 int winpr_image_write(wImage* image, const char* filename)
 {
 	WINPR_ASSERT(image);
-	return winpr_image_write_ex(image, image->type, filename);
+	return winpr_image_write_ex(image, WINPR_ASSERTING_INT_CAST(uint32_t, image->type), filename);
 }
 
 int winpr_image_write_ex(wImage* image, UINT32 format, const char* filename)
@@ -458,14 +459,17 @@ static int winpr_image_bitmap_read_buffer(wImage* image, const BYTE* buffer, siz
 	image->bitsPerPixel = bi.biBitCount;
 	image->bytesPerPixel = (image->bitsPerPixel / 8UL);
 	const size_t bpp = (bi.biBitCount + 7UL) / 8UL;
-	image->scanline = (UINT32)(bi.biWidth * bpp);
+	image->scanline =
+	    WINPR_ASSERTING_INT_CAST(uint32_t, bi.biWidth) * WINPR_ASSERTING_INT_CAST(uint32_t, bpp);
 	const size_t bmpsize = 1ULL * image->scanline * image->height;
 	if (bmpsize != bi.biSizeImage)
 		WLog_WARN(TAG, "bmpsize=%" PRIuz " != bi.biSizeImage=%" PRIu32, bmpsize, bi.biSizeImage);
 	if (bi.biSizeImage < bmpsize)
 		goto fail;
 
-	image->data = (BYTE*)malloc(bi.biSizeImage);
+	image->data = NULL;
+	if (bi.biSizeImage > 0)
+		image->data = (BYTE*)malloc(bi.biSizeImage);
 
 	if (!image->data)
 		goto fail;

winpr/libwinpr/utils/print.c

@@ -176,11 +176,11 @@ fail:
 static BYTE value(char c)
 {
 	if ((c >= '0') && (c <= '9'))
-		return c - '0';
+		return (c - '0') & 0xFF;
 	if ((c >= 'A') && (c <= 'F'))
-		return 10 + c - 'A';
+		return (10 + c - 'A') & 0xFF;
 	if ((c >= 'a') && (c <= 'f'))
-		return 10 + c - 'a';
+		return (10 + c - 'a') & 0xFF;
 	return 0;
 }
 

winpr/libwinpr/utils/sam.c

@@ -27,6 +27,7 @@
 #include <winpr/wtypes.h>
 #include <winpr/crt.h>
 #include <winpr/sam.h>
+#include <winpr/cast.h>
 #include <winpr/print.h>
 #include <winpr/file.h>
 
@@ -185,16 +186,13 @@ static void SamLookupFinish(WINPR_SAM* sam)
 
 static BOOL SamReadEntry(WINPR_SAM* sam, WINPR_SAM_ENTRY* entry)
 {
-	char* p[5];
-	size_t LmHashLength = 0;
-	size_t NtHashLength = 0;
+	char* p[5] = { 0 };
 	size_t count = 0;
-	char* cur = NULL;
 
 	if (!sam || !entry || !sam->line)
 		return FALSE;
 
-	cur = sam->line;
+	char* cur = sam->line;
 
 	while ((cur = strchr(cur, ':')) != NULL)
 	{
@@ -210,8 +208,8 @@ static BOOL SamReadEntry(WINPR_SAM* sam, WINPR_SAM_ENTRY* entry)
 	p[2] = strchr(p[1], ':') + 1;
 	p[3] = strchr(p[2], ':') + 1;
 	p[4] = strchr(p[3], ':') + 1;
-	LmHashLength = (p[3] - p[2] - 1);
-	NtHashLength = (p[4] - p[3] - 1);
+	const size_t LmHashLength = WINPR_ASSERTING_INT_CAST(size_t, (p[3] - p[2] - 1));
+	const size_t NtHashLength = WINPR_ASSERTING_INT_CAST(size_t, (p[4] - p[3] - 1));
 
 	if ((LmHashLength != 0) && (LmHashLength != 32))
 		return FALSE;

winpr/libwinpr/utils/strlst.c

@@ -47,7 +47,7 @@ int string_list_length(const char** string_list)
 char** string_list_copy(const char** string_list)
 {
 	int length = string_list_length(string_list);
-	char** copy = (char**)calloc(length + 1, sizeof(char*));
+	char** copy = (char**)calloc(WINPR_ASSERTING_INT_CAST(size_t, length) + 1, sizeof(char*));
 
 	if (!copy)
 	{

winpr/libwinpr/utils/test/TestArrayList.c

@@ -5,6 +5,7 @@
 
 int TestArrayList(int argc, char* argv[])
 {
+	int res = -1;
 	SSIZE_T rc = 0;
 	size_t val = 0;
 	const size_t elemsToInsert = 10;
@@ -19,7 +20,7 @@ int TestArrayList(int argc, char* argv[])
 	for (size_t index = 0; index < elemsToInsert; index++)
 	{
 		if (!ArrayList_Append(arrayList, (void*)index))
-			return -1;
+			goto fail;
 	}
 
 	size_t count = ArrayList_Count(arrayList);
@@ -31,7 +32,7 @@ int TestArrayList(int argc, char* argv[])
 	printf("ArrayList index: %" PRIdz "\n", index);
 
 	if (index != 6)
-		return -1;
+		goto fail;
 
 	ArrayList_Insert(arrayList, 5, (void*)(size_t)100);
 
@@ -39,7 +40,7 @@ int TestArrayList(int argc, char* argv[])
 	printf("ArrayList index: %" PRIdz "\n", index);
 
 	if (index != 7)
-		return -1;
+		goto fail;
 
 	ArrayList_Remove(arrayList, (void*)(size_t)100);
 
@@ -47,34 +48,37 @@ int TestArrayList(int argc, char* argv[])
 	printf("ArrayList index: %d\n", rc);
 
 	if (rc != 6)
-		return -1;
+		goto fail;
 
 	for (size_t index = 0; index < elemsToInsert; index++)
 	{
 		val = (size_t)ArrayList_GetItem(arrayList, 0);
 		if (!ArrayList_RemoveAt(arrayList, 0))
-			return -1;
+			goto fail;
+
 		if (val != index)
 		{
 			printf("ArrayList: shifted %" PRIdz " entries, expected value %" PRIdz ", got %" PRIdz
 			       "\n",
 			       index, index, val);
-			return -1;
+			goto fail;
 		}
 	}
 
 	rc = ArrayList_IndexOf(arrayList, (void*)elemsToInsert, -1, -1);
 	printf("ArrayList index: %d\n", rc);
 	if (rc != -1)
-		return -1;
+		goto fail;
 
 	count = ArrayList_Count(arrayList);
 	printf("ArrayList count: %" PRIuz "\n", count);
 	if (count != 0)
-		return -1;
+		goto fail;
 
 	ArrayList_Clear(arrayList);
+	res = 0;
+fail:
 	ArrayList_Free(arrayList);
 
-	return 0;
+	return res;
 }

winpr/libwinpr/utils/wlog/Layout.c

@@ -156,12 +156,12 @@ static const char* skip_if_null(const struct format_option* opt, const char* fmt
 	const char* end = strstr(str, opt->replace);
 	if (!end)
 		return NULL;
-	*pskiplen = end - fmt + opt->replacelen;
+	*pskiplen = WINPR_ASSERTING_INT_CAST(size_t, end - fmt) + opt->replacelen;
 
 	if (!opt->arg)
 		return NULL;
 
-	const size_t replacelen = end - str;
+	const size_t replacelen = WINPR_ASSERTING_INT_CAST(size_t, end - str);
 
 	char buffer[WLOG_MAX_PREFIX_SIZE] = { 0 };
 	memcpy(buffer, str, MIN(replacelen, ARRAYSIZE(buffer) - 1));
@@ -207,9 +207,10 @@ static BOOL replace_format_string(const char* FormatString, struct format_option
 				WINPR_PRAGMA_DIAG_POP
 				if (rc < 0)
 					return FALSE;
-				if (!check_and_log_format_size(format, formatlen, index, rc))
+				if (!check_and_log_format_size(format, formatlen, index,
+				                               WINPR_ASSERTING_INT_CAST(size_t, rc)))
 					return FALSE;
-				index += rc;
+				index += WINPR_ASSERTING_INT_CAST(size_t, rc);
 			}
 			FormatString += fmtlen;
 		}

winpr/libwinpr/utils/wlog/UdpAppender.c

@@ -42,7 +42,6 @@ static BOOL WLog_UdpAppender_Open(wLog* log, wLogAppender* appender)
 	struct addrinfo hints = { 0 };
 	struct addrinfo* result = { 0 };
 	int status = 0;
-	size_t addrLen = 0;
 	char* colonPos = NULL;
 
 	if (!appender)
@@ -58,7 +57,7 @@ static BOOL WLog_UdpAppender_Open(wLog* log, wLogAppender* appender)
 	if (!colonPos)
 		return FALSE;
 
-	addrLen = (colonPos - udpAppender->host);
+	const size_t addrLen = WINPR_ASSERTING_INT_CAST(size_t, (colonPos - udpAppender->host));
 	memcpy(addressString, udpAppender->host, addrLen);
 	addressString[addrLen] = '\0';
 	hints.ai_family = AF_INET;

winpr/libwinpr/winsock/winsock.c

@@ -1005,12 +1005,11 @@ int WSAIoctl(SOCKET s, DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuff
 
 SOCKET _accept(SOCKET s, struct sockaddr* addr, int* addrlen)
 {
-	int status = 0;
-	int fd = (int)s;
+	int fd = WINPR_ASSERTING_INT_CAST(int, s);
 	socklen_t s_addrlen = (socklen_t)*addrlen;
-	status = accept(fd, addr, &s_addrlen);
+	const int status = accept(fd, addr, &s_addrlen);
 	*addrlen = (int)s_addrlen;
-	return status;
+	return (SOCKET)status;
 }
 
 int _bind(SOCKET s, const struct sockaddr* addr, int namelen)
@@ -1114,7 +1113,7 @@ u_short _htons(u_short hostshort)
 
 unsigned long _inet_addr(const char* cp)
 {
-	return (long)inet_addr(cp);
+	return WINPR_ASSERTING_INT_CAST(unsigned long, inet_addr(cp));
 }
 
 char* _inet_ntoa(struct in_addr in)

winpr/tools/makecert/makecert.c

@@ -963,7 +963,7 @@ int makecert_context_process(MAKECERT_CONTEXT* context, int argc, char** argv)
 		key_length = (int)val;
 	}
 
-	if (!makecert_create_rsa(&context->pkey, key_length))
+	if (!makecert_create_rsa(&context->pkey, WINPR_ASSERTING_INT_CAST(size_t, key_length)))
 		return -1;
 
 	X509_set_version(context->x509, 2);