sync with OpenBSD -current

lib/libcrypto/asn1/ameth_lib.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: ameth_lib.c,v 1.33 2023/11/19 15:46:09 tb Exp $ */
+/* $OpenBSD: ameth_lib.c,v 1.34 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -158,6 +158,9 @@ EVP_PKEY_asn1_find(ENGINE **pe, int type)
 {
 	const EVP_PKEY_ASN1_METHOD *mp;
 
+	if (pe != NULL)
+		*pe = NULL;
+
 	for (;;) {
 		if ((mp = pkey_asn1_find(type)) == NULL)
 			break;
@@ -165,9 +168,7 @@ EVP_PKEY_asn1_find(ENGINE **pe, int type)
 			break;
 		type = mp->pkey_base_id;
 	}
-	if (pe) {
+
-		*pe = NULL;
-	}
 	return mp;
 }
 
@@ -179,9 +180,8 @@ EVP_PKEY_asn1_find_str(ENGINE **pe, const char *str, int len)
 
 	if (len == -1)
 		len = strlen(str);
-	if (pe) {
+	if (pe != NULL)
 		*pe = NULL;
-	}
 	for (i = EVP_PKEY_asn1_get_count() - 1; i >= 0; i--) {
 		ameth = EVP_PKEY_asn1_get0(i);
 		if (ameth->pkey_flags & ASN1_PKEY_ALIAS)

lib/libcrypto/cmac/cm_pmeth.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cm_pmeth.c,v 1.10 2022/11/26 16:08:51 tb Exp $ */
+/* $OpenBSD: cm_pmeth.c,v 1.11 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2010.
  */
@@ -143,7 +143,7 @@ pkey_cmac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 		break;
 
 	case EVP_PKEY_CTRL_CIPHER:
-		if (!CMAC_Init(cmctx, NULL, 0, p2, ctx->engine))
+		if (!CMAC_Init(cmctx, NULL, 0, p2, NULL))
 			return 0;
 		break;
 

lib/libcrypto/cmac/cmac.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: cmac.c,v 1.14 2023/07/08 14:27:14 beck Exp $ */
+/* $OpenBSD: cmac.c,v 1.16 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -59,37 +59,52 @@
 
 #include "evp_local.h"
 
+/*
+ * This implementation follows https://doi.org/10.6028/NIST.SP.800-38B
+ */
+
+/*
+ * CMAC context. k1 and k2 are the secret subkeys, computed as in section 6.1.
+ * The temporary block tbl is a scratch buffer that holds intermediate secrets.
+ */
 struct CMAC_CTX_st {
-	/* Cipher context to use */
 	EVP_CIPHER_CTX cctx;
-	/* Keys k1 and k2 */
 	unsigned char k1[EVP_MAX_BLOCK_LENGTH];
 	unsigned char k2[EVP_MAX_BLOCK_LENGTH];
-	/* Temporary block */
 	unsigned char tbl[EVP_MAX_BLOCK_LENGTH];
-	/* Last (possibly partial) block */
 	unsigned char last_block[EVP_MAX_BLOCK_LENGTH];
-	/* Number of bytes in last block: -1 means context not initialised */
+	/* Bytes in last block. -1 means not initialized. */
 	int nlast_block;
 };
 
-
+/*
-/* Make temporary keys K1 and K2 */
+ * SP 800-38B, section 6.1, steps 2 and 3: given the input key l, calculate
-
+ * the subkeys k1 and k2: shift l one bit to the left. If the most significant
+ * bit of l was 1, additionally xor the result with Rb to get kn.
+ *
+ * Step 2: calculate k1 with l being the intermediate block CIPH_K(0),
+ * Step 3: calculate k2 from l == k1.
+ *
+ * Per 5.3, Rb is the lexically first irreducible polynomial of degree b with
+ * the minimum number of non-zero terms. This gives R128 = (1 << 128) | 0x87
+ * and R64 = (1 << 64) | 0x1b for the only supported block sizes 128 and 64.
+ */
 static void
-make_kn(unsigned char *k1, unsigned char *l, int bl)
+make_kn(unsigned char *kn, const unsigned char *l, int bl)
 {
+	unsigned char mask, Rb;
 	int i;
 
-	/* Shift block to left, including carry */
+	/* Choose Rb according to the block size in bytes. */
-	for (i = 0; i < bl; i++) {
+	Rb = bl == 16 ? 0x87 : 0x1b;
-		k1[i] = l[i] << 1;
+
-		if (i < bl - 1 && l[i + 1] & 0x80)
+	/* Compute l << 1 up to last byte. */
-			k1[i] |= 1;
+	for (i = 0; i < bl - 1; i++)
-	}
+		kn[i] = (l[i] << 1) | (l[i + 1] >> 7);
-	/* If MSB set fixup with R */
+
-	if (l[0] & 0x80)
+	/* Only xor with Rb if the MSB is one. */
-		k1[bl - 1] ^= bl == 16 ? 0x87 : 0x1b;
+	mask = 0 - (l[0] >> 7);
+	kn[bl - 1] = (l[bl - 1] << 1) ^ (Rb & mask);
 }
 
 CMAC_CTX *
@@ -160,44 +175,61 @@ CMAC_Init(CMAC_CTX *ctx, const void *key, size_t keylen,
     const EVP_CIPHER *cipher, ENGINE *impl)
 {
 	static unsigned char zero_iv[EVP_MAX_BLOCK_LENGTH];
+	int bl;
 
 	/* All zeros means restart */
-	if (!key && !cipher && !impl && keylen == 0) {
+	if (key == NULL && cipher == NULL && keylen == 0) {
 		/* Not initialised */
 		if (ctx->nlast_block == -1)
 			return 0;
 		if (!EVP_EncryptInit_ex(&ctx->cctx, NULL, NULL, NULL, zero_iv))
 			return 0;
-		memset(ctx->tbl, 0, EVP_CIPHER_CTX_block_size(&ctx->cctx));
+		explicit_bzero(ctx->tbl, sizeof(ctx->tbl));
 		ctx->nlast_block = 0;
 		return 1;
 	}
-	/* Initialise context */
-	if (cipher && !EVP_EncryptInit_ex(&ctx->cctx, cipher, impl, NULL, NULL))
-		return 0;
-	/* Non-NULL key means initialisation complete */
-	if (key) {
-		int bl;
 
-		if (!EVP_CIPHER_CTX_cipher(&ctx->cctx))
+	/* Initialise context. */
+	if (cipher != NULL) {
+		if (!EVP_EncryptInit_ex(&ctx->cctx, cipher, NULL, NULL, NULL))
 			return 0;
+	}
+
+	/* Non-NULL key means initialisation is complete. */
+	if (key != NULL) {
+		if (EVP_CIPHER_CTX_cipher(&ctx->cctx) == NULL)
+			return 0;
+
+		/* make_kn() only supports block sizes of 8 and 16 bytes. */
+		bl = EVP_CIPHER_CTX_block_size(&ctx->cctx);
+		if (bl != 8 && bl != 16)
+			return 0;
+
+		/*
+		 * Section 6.1, step 1: store the intermediate secret CIPH_K(0)
+		 * in ctx->tbl.
+		 */
 		if (!EVP_CIPHER_CTX_set_key_length(&ctx->cctx, keylen))
 			return 0;
 		if (!EVP_EncryptInit_ex(&ctx->cctx, NULL, NULL, key, zero_iv))
 			return 0;
-		bl = EVP_CIPHER_CTX_block_size(&ctx->cctx);
 		if (!EVP_Cipher(&ctx->cctx, ctx->tbl, zero_iv, bl))
 			return 0;
+
+		/* Section 6.1, step 2: compute k1 from intermediate secret. */
 		make_kn(ctx->k1, ctx->tbl, bl);
+		/* Section 6.1, step 3: compute k2 from k1. */
 		make_kn(ctx->k2, ctx->k1, bl);
-		explicit_bzero(ctx->tbl, bl);
+
-		/* Reset context again ready for first data block */
+		/* Destroy intermediate secret and reset last block count. */
+		explicit_bzero(ctx->tbl, sizeof(ctx->tbl));
+		ctx->nlast_block = 0;
+
+		/* Reset context again to get ready for the first data block. */
 		if (!EVP_EncryptInit_ex(&ctx->cctx, NULL, NULL, NULL, zero_iv))
 			return 0;
-		/* Zero tbl so resume works */
-		memset(ctx->tbl, 0, bl);
-		ctx->nlast_block = 0;
 	}
+
 	return 1;
 }
 LCRYPTO_ALIAS(CMAC_Init);

lib/libcrypto/dh/dh_lib.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: dh_lib.c,v 1.42 2023/11/19 15:46:09 tb Exp $ */
+/* $OpenBSD: dh_lib.c,v 1.43 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -230,7 +230,7 @@ LCRYPTO_ALIAS(DH_security_bits);
 ENGINE *
 DH_get0_engine(DH *dh)
 {
-	return dh->engine;
+	return NULL;
 }
 LCRYPTO_ALIAS(DH_get0_engine);
 

lib/libcrypto/dh/dh_local.h

@@ -1,4 +1,4 @@
-/* $OpenBSD: dh_local.h,v 1.3 2022/01/14 08:25:44 tb Exp $ */
+/* $OpenBSD: dh_local.h,v 1.4 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -100,7 +100,6 @@ struct dh_st {
 	int references;
 	CRYPTO_EX_DATA ex_data;
 	const DH_METHOD *meth;
-	ENGINE *engine;
 };
 
 /*

lib/libcrypto/dsa/dsa_lib.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_lib.c,v 1.45 2023/11/19 15:46:09 tb Exp $ */
+/* $OpenBSD: dsa_lib.c,v 1.46 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -397,7 +397,7 @@ LCRYPTO_ALIAS(DSA_set_flags);
 ENGINE *
 DSA_get0_engine(DSA *d)
 {
-	return d->engine;
+	return NULL;
 }
 LCRYPTO_ALIAS(DSA_get0_engine);
 

lib/libcrypto/dsa/dsa_local.h

@@ -1,4 +1,4 @@
-/* $OpenBSD: dsa_local.h,v 1.2 2023/03/04 20:54:52 tb Exp $ */
+/* $OpenBSD: dsa_local.h,v 1.3 2023/11/29 21:35:57 tb Exp $ */
 /* ====================================================================
  * Copyright (c) 2007 The OpenSSL Project.  All rights reserved.
  *
@@ -106,8 +106,6 @@ struct dsa_st {
 	int references;
 	CRYPTO_EX_DATA ex_data;
 	const DSA_METHOD *meth;
-	/* functional reference if 'meth' is ENGINE-provided */
-	ENGINE *engine;
 } /* DSA */;
 
 int dsa_builtin_paramgen(DSA *ret, size_t bits, size_t qbits,

lib/libcrypto/ec/ec_key.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_key.c,v 1.38 2023/11/19 15:46:09 tb Exp $ */
+/* $OpenBSD: ec_key.c,v 1.39 2023/11/29 21:35:57 tb Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -191,7 +191,7 @@ EC_KEY_dup(const EC_KEY *ec_key)
 {
 	EC_KEY *ret;
 
-	if ((ret = EC_KEY_new_method(ec_key->engine)) == NULL)
+	if ((ret = EC_KEY_new_method(NULL)) == NULL)
 		return NULL;
 	if (EC_KEY_copy(ret, ec_key) == NULL) {
 		EC_KEY_free(ret);

lib/libcrypto/ec/ec_local.h

@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_local.h,v 1.26 2023/07/28 15:50:33 tb Exp $ */
+/* $OpenBSD: ec_local.h,v 1.27 2023/11/29 21:35:57 tb Exp $ */
 /*
  * Originally written by Bodo Moeller for the OpenSSL project.
  */
@@ -223,7 +223,6 @@ struct ec_group_st {
 
 struct ec_key_st {
 	const EC_KEY_METHOD *meth;
-	ENGINE	*engine;
 
 	int version;
 

lib/libcrypto/evp/digest.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: digest.c,v 1.39 2023/11/19 15:46:09 tb Exp $ */
+/* $OpenBSD: digest.c,v 1.40 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -271,7 +271,7 @@ EVP_Digest(const void *data, size_t count,
 
 	EVP_MD_CTX_init(&ctx);
 	EVP_MD_CTX_set_flags(&ctx, EVP_MD_CTX_FLAG_ONESHOT);
-	ret = EVP_DigestInit_ex(&ctx, type, impl) &&
+	ret = EVP_DigestInit_ex(&ctx, type, NULL) &&
 	    EVP_DigestUpdate(&ctx, data, count) &&
 	    EVP_DigestFinal_ex(&ctx, md, size);
 	EVP_MD_CTX_cleanup(&ctx);

lib/libcrypto/evp/evp_enc.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_enc.c,v 1.55 2023/11/19 15:46:09 tb Exp $ */
+/* $OpenBSD: evp_enc.c,v 1.56 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -93,7 +93,7 @@ EVP_CipherInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
 	if (cipher) {
 		/* Ensure a context left lying around from last time is cleared
 		 * (the previous check attempted to avoid this if the same
-		 * ENGINE and EVP_CIPHER could be used). */
+		 * EVP_CIPHER could be used). */
 		if (ctx->cipher) {
 			unsigned long flags = ctx->flags;
 			EVP_CIPHER_CTX_cleanup(ctx);
@@ -236,7 +236,7 @@ int
 EVP_EncryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
     const unsigned char *key, const unsigned char *iv)
 {
-	return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 1);
+	return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, 1);
 }
 
 int
@@ -250,7 +250,7 @@ int
 EVP_DecryptInit_ex(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, ENGINE *impl,
     const unsigned char *key, const unsigned char *iv)
 {
-	return EVP_CipherInit_ex(ctx, cipher, impl, key, iv, 0);
+	return EVP_CipherInit_ex(ctx, cipher, NULL, key, iv, 0);
 }
 
 int

lib/libcrypto/evp/evp_local.h

@@ -1,4 +1,4 @@
-/* $OpenBSD: evp_local.h,v 1.5 2023/09/28 11:29:10 tb Exp $ */
+/* $OpenBSD: evp_local.h,v 1.6 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2000.
  */
@@ -97,7 +97,6 @@ struct evp_pkey_st {
 	int save_type;
 	int references;
 	const EVP_PKEY_ASN1_METHOD *ameth;
-	ENGINE *engine;
 	union	{
 		void *ptr;
 #ifndef OPENSSL_NO_RSA
@@ -140,7 +139,6 @@ struct evp_md_st {
 
 struct evp_md_ctx_st {
 	const EVP_MD *digest;
-	ENGINE *engine; /* functional reference if 'digest' is ENGINE-provided */
 	unsigned long flags;
 	void *md_data;
 	/* Public key context for sign/verify */
@@ -169,7 +167,6 @@ struct evp_cipher_st {
 
 struct evp_cipher_ctx_st {
 	const EVP_CIPHER *cipher;
-	ENGINE *engine;	/* functional reference if 'cipher' is ENGINE-provided */
 	int encrypt;		/* encrypt or decrypt */
 	int buf_len;		/* number we have left */
 
@@ -205,8 +202,6 @@ struct evp_Encode_Ctx_st {
 struct evp_pkey_ctx_st {
 	/* Method associated with this operation */
 	const EVP_PKEY_METHOD *pmeth;
-	/* Engine that implements this method or NULL if builtin */
-	ENGINE *engine;
 	/* Key: may be NULL */
 	EVP_PKEY *pkey;
 	/* Peer key for key agreement, may be NULL */

lib/libcrypto/evp/m_sigver.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: m_sigver.c,v 1.13 2023/07/07 19:37:53 beck Exp $ */
+/* $OpenBSD: m_sigver.c,v 1.14 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -74,10 +74,10 @@ update_oneshot_only(EVP_MD_CTX *ctx, const void *data, size_t datalen)
 
 static int
 do_sigver_init(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
-    ENGINE *e, EVP_PKEY *pkey, int ver)
+    EVP_PKEY *pkey, int ver)
 {
 	if (ctx->pctx == NULL)
-		ctx->pctx = EVP_PKEY_CTX_new(pkey, e);
+		ctx->pctx = EVP_PKEY_CTX_new(pkey, NULL);
 	if (ctx->pctx == NULL)
 		return 0;
 
@@ -122,7 +122,7 @@ do_sigver_init(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
 		*pctx = ctx->pctx;
 	if (ctx->pctx->pmeth->flags & EVP_PKEY_FLAG_SIGCTX_CUSTOM)
 		return 1;
-	if (!EVP_DigestInit_ex(ctx, type, e))
+	if (!EVP_DigestInit_ex(ctx, type, NULL))
 		return 0;
 	return 1;
 }
@@ -131,14 +131,14 @@ int
 EVP_DigestSignInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
     ENGINE *e, EVP_PKEY *pkey)
 {
-	return do_sigver_init(ctx, pctx, type, e, pkey, 0);
+	return do_sigver_init(ctx, pctx, type, pkey, 0);
 }
 
 int
 EVP_DigestVerifyInit(EVP_MD_CTX *ctx, EVP_PKEY_CTX **pctx, const EVP_MD *type,
     ENGINE *e, EVP_PKEY *pkey)
 {
-	return do_sigver_init(ctx, pctx, type, e, pkey, 1);
+	return do_sigver_init(ctx, pctx, type, pkey, 1);
 }
 
 int

lib/libcrypto/evp/p_lib.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: p_lib.c,v 1.38 2023/11/19 15:46:10 tb Exp $ */
+/* $OpenBSD: p_lib.c,v 1.39 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -206,7 +206,6 @@ EVP_PKEY_new(void)
 	ret->save_type = EVP_PKEY_NONE;
 	ret->references = 1;
 	ret->ameth = NULL;
-	ret->engine = NULL;
 	ret->pkey.ptr = NULL;
 	ret->attributes = NULL;
 	ret->save_parameters = 1;
@@ -220,18 +219,14 @@ EVP_PKEY_up_ref(EVP_PKEY *pkey)
 	return ((refs > 1) ? 1 : 0);
 }
 
-/* Setup a public key ASN1 method and ENGINE from a NID or a string.
+/* Setup a public key ASN1 method from a NID or a string.
  * If pkey is NULL just return 1 or 0 if the algorithm exists.
  */
 
 static int
-pkey_set_type(EVP_PKEY *pkey, ENGINE *e, int type, const char *str, int len)
+pkey_set_type(EVP_PKEY *pkey, int type, const char *str, int len)
 {
 	const EVP_PKEY_ASN1_METHOD *ameth;
-	ENGINE **eptr = NULL;
-
-	if (e == NULL)
-		eptr = &e;
 
 	if (pkey) {
 		if (pkey->pkey.ptr)
@@ -242,17 +237,16 @@ pkey_set_type(EVP_PKEY *pkey, ENGINE *e, int type, const char *str, int len)
 		if ((type == pkey->save_type) && pkey->ameth)
 			return 1;
 	}
-	if (str)
+	if (str != NULL)
-		ameth = EVP_PKEY_asn1_find_str(eptr, str, len);
+		ameth = EVP_PKEY_asn1_find_str(NULL, str, len);
 	else
-		ameth = EVP_PKEY_asn1_find(eptr, type);
+		ameth = EVP_PKEY_asn1_find(NULL, type);
 	if (!ameth) {
 		EVPerror(EVP_R_UNSUPPORTED_ALGORITHM);
 		return 0;
 	}
 	if (pkey) {
 		pkey->ameth = ameth;
-		pkey->engine = e;
 
 		pkey->type = pkey->ameth->pkey_id;
 		pkey->save_type = type;
@@ -263,7 +257,7 @@ pkey_set_type(EVP_PKEY *pkey, ENGINE *e, int type, const char *str, int len)
 int
 EVP_PKEY_set_type(EVP_PKEY *pkey, int type)
 {
-	return pkey_set_type(pkey, NULL, type, NULL, -1);
+	return pkey_set_type(pkey, type, NULL, -1);
 }
 
 EVP_PKEY *
@@ -275,7 +269,7 @@ EVP_PKEY_new_raw_private_key(int type, ENGINE *engine,
 	if ((ret = EVP_PKEY_new()) == NULL)
 		goto err;
 
-	if (!pkey_set_type(ret, engine, type, NULL, -1))
+	if (!pkey_set_type(ret, type, NULL, -1))
 		goto err;
 
 	if (ret->ameth->set_priv_key == NULL) {
@@ -304,7 +298,7 @@ EVP_PKEY_new_raw_public_key(int type, ENGINE *engine,
 	if ((ret = EVP_PKEY_new()) == NULL)
 		goto err;
 
-	if (!pkey_set_type(ret, engine, type, NULL, -1))
+	if (!pkey_set_type(ret, type, NULL, -1))
 		goto err;
 
 	if (ret->ameth->set_pub_key == NULL) {
@@ -368,10 +362,10 @@ EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv, size_t len,
 	if ((cmctx = CMAC_CTX_new()) == NULL)
 		goto err;
 
-	if (!pkey_set_type(ret, e, EVP_PKEY_CMAC, NULL, -1))
+	if (!pkey_set_type(ret, EVP_PKEY_CMAC, NULL, -1))
 		goto err;
 
-	if (!CMAC_Init(cmctx, priv, len, cipher, e)) {
+	if (!CMAC_Init(cmctx, priv, len, cipher, NULL)) {
 		EVPerror(EVP_R_KEY_SETUP_FAILED);
 		goto err;
 	}
@@ -389,7 +383,7 @@ EVP_PKEY_new_CMAC_key(ENGINE *e, const unsigned char *priv, size_t len,
 int
 EVP_PKEY_set_type_str(EVP_PKEY *pkey, const char *str, int len)
 {
-	return pkey_set_type(pkey, NULL, EVP_PKEY_NONE, str, len);
+	return pkey_set_type(pkey, EVP_PKEY_NONE, str, len);
 }
 
 int
@@ -563,15 +557,12 @@ EVP_PKEY_set1_DH(EVP_PKEY *pkey, DH *key)
 int
 EVP_PKEY_type(int type)
 {
-	int ret;
 	const EVP_PKEY_ASN1_METHOD *ameth;
-	ENGINE *e;
+
-	ameth = EVP_PKEY_asn1_find(&e, type);
+	if ((ameth = EVP_PKEY_asn1_find(NULL, type)) != NULL)
-	if (ameth)
+		return ameth->pkey_id;
-		ret = ameth->pkey_id;
+
-	else
+	return NID_undef;
-		ret = NID_undef;
-	return ret;
 }
 
 int

lib/libcrypto/evp/pmeth_gn.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_gn.c,v 1.13 2023/07/07 19:37:54 beck Exp $ */
+/* $OpenBSD: pmeth_gn.c,v 1.14 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -208,7 +208,7 @@ EVP_PKEY_new_mac_key(int type, ENGINE *e, const unsigned char *key, int keylen)
 	EVP_PKEY_CTX *mac_ctx = NULL;
 	EVP_PKEY *mac_key = NULL;
 
-	mac_ctx = EVP_PKEY_CTX_new_id(type, e);
+	mac_ctx = EVP_PKEY_CTX_new_id(type, NULL);
 	if (!mac_ctx)
 		return NULL;
 	if (EVP_PKEY_keygen_init(mac_ctx) <= 0)

lib/libcrypto/evp/pmeth_lib.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: pmeth_lib.c,v 1.34 2023/11/19 15:43:52 tb Exp $ */
+/* $OpenBSD: pmeth_lib.c,v 1.35 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2006.
  */
@@ -147,7 +147,7 @@ EVP_PKEY_meth_find(int type)
 }
 
 static EVP_PKEY_CTX *
-evp_pkey_ctx_new(EVP_PKEY *pkey, ENGINE *engine, int id)
+evp_pkey_ctx_new(EVP_PKEY *pkey, int id)
 {
 	EVP_PKEY_CTX *pkey_ctx = NULL;
 	const EVP_PKEY_METHOD *pmeth;
@@ -167,8 +167,6 @@ evp_pkey_ctx_new(EVP_PKEY *pkey, ENGINE *engine, int id)
 		EVPerror(ERR_R_MALLOC_FAILURE);
 		goto err;
 	}
-	pkey_ctx->engine = engine;
-	engine = NULL;
 	pkey_ctx->pmeth = pmeth;
 	pkey_ctx->operation = EVP_PKEY_OP_UNDEFINED;
 	if ((pkey_ctx->pkey = pkey) != NULL)
@@ -234,13 +232,13 @@ EVP_PKEY_meth_free(EVP_PKEY_METHOD *pmeth)
 EVP_PKEY_CTX *
 EVP_PKEY_CTX_new(EVP_PKEY *pkey, ENGINE *engine)
 {
-	return evp_pkey_ctx_new(pkey, engine, -1);
+	return evp_pkey_ctx_new(pkey, -1);
 }
 
 EVP_PKEY_CTX *
 EVP_PKEY_CTX_new_id(int id, ENGINE *engine)
 {
-	return evp_pkey_ctx_new(NULL, engine, id);
+	return evp_pkey_ctx_new(NULL, id);
 }
 
 EVP_PKEY_CTX *

lib/libcrypto/hmac/hm_pmeth.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: hm_pmeth.c,v 1.15 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: hm_pmeth.c,v 1.16 2023/11/29 21:35:57 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2007.
  */
@@ -204,7 +204,7 @@ pkey_hmac_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2)
 	case EVP_PKEY_CTRL_DIGESTINIT:
 		key = ctx->pkey->pkey.ptr;
 		if (!HMAC_Init_ex(&hctx->ctx, key->data, key->length, hctx->md,
-		    ctx->engine))
+		    NULL))
 			return 0;
 		break;
 

lib/libcrypto/pem/pem_lib.c

@@ -1,4 +1,4 @@
-/* $OpenBSD: pem_lib.c,v 1.54 2023/11/19 15:46:10 tb Exp $ */
+/* $OpenBSD: pem_lib.c,v 1.55 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -220,8 +220,7 @@ check_pem(const char *nm, const char *name)
 		const EVP_PKEY_ASN1_METHOD *ameth;
 		slen = pem_check_suffix(nm, "PARAMETERS");
 		if (slen > 0) {
-			ENGINE *e;
+			ameth = EVP_PKEY_asn1_find_str(NULL, nm, slen);
-			ameth = EVP_PKEY_asn1_find_str(&e, nm, slen);
 			if (ameth) {
 				int r;
 				if (ameth->param_decode)

lib/libcrypto/rsa/rsa_local.h

@@ -1,4 +1,4 @@
-/* $OpenBSD: rsa_local.h,v 1.6 2023/08/09 12:09:06 tb Exp $ */
+/* $OpenBSD: rsa_local.h,v 1.7 2023/11/29 21:35:57 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -108,8 +108,6 @@ struct rsa_st {
 	long version;
 	const RSA_METHOD *meth;
 
-	/* functional reference if 'meth' is ENGINE-provided */
-	ENGINE *engine;
 	BIGNUM *n;
 	BIGNUM *e;
 	BIGNUM *d;

sys/arch/arm64/include/armreg.h

@@ -1,4 +1,4 @@
-/* $OpenBSD: armreg.h,v 1.29 2023/06/10 19:30:48 kettenis Exp $ */
+/* $OpenBSD: armreg.h,v 1.30 2023/11/29 23:32:16 kettenis Exp $ */
 /*-
  * Copyright (c) 2013, 2014 Andrew Turner
  * Copyright (c) 2015 The FreeBSD Foundation
@@ -218,69 +218,69 @@
 /* ID_AA64DFR0_EL1 */
 #define	ID_AA64DFR0_MASK		0x00000000f0f0ffffUL
 #define	ID_AA64DFR0_DEBUG_VER_SHIFT	0
-#define	ID_AA64DFR0_DEBUG_VER_MASK	(0xf << ID_AA64DFR0_DEBUG_VER_SHIFT)
+#define	ID_AA64DFR0_DEBUG_VER_MASK	(0xfULL << ID_AA64DFR0_DEBUG_VER_SHIFT)
 #define	ID_AA64DFR0_DEBUG_VER(x)	((x) & ID_AA64DFR0_DEBUG_VER_MASK)
-#define	 ID_AA64DFR0_DEBUG_VER_8	(0x6 << ID_AA64DFR0_DEBUG_VER_SHIFT)
+#define	 ID_AA64DFR0_DEBUG_VER_8	(0x6ULL << ID_AA64DFR0_DEBUG_VER_SHIFT)
-#define	 ID_AA64DFR0_DEBUG_VER_8_VHE	(0x7 << ID_AA64DFR0_DEBUG_VER_SHIFT)
+#define	 ID_AA64DFR0_DEBUG_VER_8_VHE	(0x7ULL << ID_AA64DFR0_DEBUG_VER_SHIFT)
 #define	ID_AA64DFR0_TRACE_VER_SHIFT	4
-#define	ID_AA64DFR0_TRACE_VER_MASK	(0xf << ID_AA64DFR0_TRACE_VER_SHIFT)
+#define	ID_AA64DFR0_TRACE_VER_MASK	(0xfULL << ID_AA64DFR0_TRACE_VER_SHIFT)
 #define	ID_AA64DFR0_TRACE_VER(x)	((x) & ID_AA64DFR0_TRACE_VER_MASK)
-#define	 ID_AA64DFR0_TRACE_VER_NONE	(0x0 << ID_AA64DFR0_TRACE_VER_SHIFT)
+#define	 ID_AA64DFR0_TRACE_VER_NONE	(0x0ULL << ID_AA64DFR0_TRACE_VER_SHIFT)
-#define	 ID_AA64DFR0_TRACE_VER_IMPL	(0x1 << ID_AA64DFR0_TRACE_VER_SHIFT)
+#define	 ID_AA64DFR0_TRACE_VER_IMPL	(0x1ULL << ID_AA64DFR0_TRACE_VER_SHIFT)
 #define	ID_AA64DFR0_PMU_VER_SHIFT	8
-#define	ID_AA64DFR0_PMU_VER_MASK	(0xf << ID_AA64DFR0_PMU_VER_SHIFT)
+#define	ID_AA64DFR0_PMU_VER_MASK	(0xfULL << ID_AA64DFR0_PMU_VER_SHIFT)
 #define	ID_AA64DFR0_PMU_VER(x)		((x) & ID_AA64DFR0_PMU_VER_MASK)
-#define	 ID_AA64DFR0_PMU_VER_NONE	(0x0 << ID_AA64DFR0_PMU_VER_SHIFT)
+#define	 ID_AA64DFR0_PMU_VER_NONE	(0x0ULL << ID_AA64DFR0_PMU_VER_SHIFT)
-#define	 ID_AA64DFR0_PMU_VER_3		(0x1 << ID_AA64DFR0_PMU_VER_SHIFT)
+#define	 ID_AA64DFR0_PMU_VER_3		(0x1ULL << ID_AA64DFR0_PMU_VER_SHIFT)
-#define	 ID_AA64DFR0_PMU_VER_3_1	(0x4 << ID_AA64DFR0_PMU_VER_SHIFT)
+#define	 ID_AA64DFR0_PMU_VER_3_1	(0x4ULL << ID_AA64DFR0_PMU_VER_SHIFT)
-#define	 ID_AA64DFR0_PMU_VER_IMPL	(0xf << ID_AA64DFR0_PMU_VER_SHIFT)
+#define	 ID_AA64DFR0_PMU_VER_IMPL	(0xfULL << ID_AA64DFR0_PMU_VER_SHIFT)
 #define	ID_AA64DFR0_BRPS_SHIFT		12
-#define	ID_AA64DFR0_BRPS_MASK		(0xf << ID_AA64DFR0_BRPS_SHIFT)
+#define	ID_AA64DFR0_BRPS_MASK		(0xfULL << ID_AA64DFR0_BRPS_SHIFT)
 #define	ID_AA64DFR0_BRPS(x)		\
     ((((x) >> ID_AA64DFR0_BRPS_SHIFT) & 0xf) + 1)
 #define	ID_AA64DFR0_WRPS_SHIFT		20
-#define	ID_AA64DFR0_WRPS_MASK		(0xf << ID_AA64DFR0_WRPS_SHIFT)
+#define	ID_AA64DFR0_WRPS_MASK		(0xfULL << ID_AA64DFR0_WRPS_SHIFT)
 #define	ID_AA64DFR0_WRPS(x)		\
     ((((x) >> ID_AA64DFR0_WRPS_SHIFT) & 0xf) + 1)
 #define	ID_AA64DFR0_CTX_CMPS_SHIFT	28
-#define	ID_AA64DFR0_CTX_CMPS_MASK	(0xf << ID_AA64DFR0_CTX_CMPS_SHIFT)
+#define	ID_AA64DFR0_CTX_CMPS_MASK	(0xfULL << ID_AA64DFR0_CTX_CMPS_SHIFT)
 #define	ID_AA64DFR0_CTX_CMPS(x)		\
     ((((x) >> ID_AA64DFR0_CTX_CMPS_SHIFT) & 0xf) + 1)
 
 /* ID_AA64ISAR0_EL1 */
 #define	ID_AA64ISAR0_MASK		0xfffffffff0fffff0ULL
 #define	ID_AA64ISAR0_AES_SHIFT		4
-#define	ID_AA64ISAR0_AES_MASK		(0xf << ID_AA64ISAR0_AES_SHIFT)
+#define	ID_AA64ISAR0_AES_MASK		(0xfULL << ID_AA64ISAR0_AES_SHIFT)
 #define	ID_AA64ISAR0_AES(x)		((x) & ID_AA64ISAR0_AES_MASK)
-#define	 ID_AA64ISAR0_AES_NONE		(0x0 << ID_AA64ISAR0_AES_SHIFT)
+#define	 ID_AA64ISAR0_AES_NONE		(0x0ULL << ID_AA64ISAR0_AES_SHIFT)
-#define	 ID_AA64ISAR0_AES_BASE		(0x1 << ID_AA64ISAR0_AES_SHIFT)
+#define	 ID_AA64ISAR0_AES_BASE		(0x1ULL << ID_AA64ISAR0_AES_SHIFT)
-#define	 ID_AA64ISAR0_AES_PMULL		(0x2 << ID_AA64ISAR0_AES_SHIFT)
+#define	 ID_AA64ISAR0_AES_PMULL		(0x2ULL << ID_AA64ISAR0_AES_SHIFT)
 #define	ID_AA64ISAR0_SHA1_SHIFT		8
-#define	ID_AA64ISAR0_SHA1_MASK		(0xf << ID_AA64ISAR0_SHA1_SHIFT)
+#define	ID_AA64ISAR0_SHA1_MASK		(0xfULL << ID_AA64ISAR0_SHA1_SHIFT)
 #define	ID_AA64ISAR0_SHA1(x)		((x) & ID_AA64ISAR0_SHA1_MASK)
-#define	 ID_AA64ISAR0_SHA1_NONE		(0x0 << ID_AA64ISAR0_SHA1_SHIFT)
+#define	 ID_AA64ISAR0_SHA1_NONE		(0x0ULL << ID_AA64ISAR0_SHA1_SHIFT)
-#define	 ID_AA64ISAR0_SHA1_BASE		(0x1 << ID_AA64ISAR0_SHA1_SHIFT)
+#define	 ID_AA64ISAR0_SHA1_BASE		(0x1ULL << ID_AA64ISAR0_SHA1_SHIFT)
 #define	ID_AA64ISAR0_SHA2_SHIFT		12
-#define	ID_AA64ISAR0_SHA2_MASK		(0xf << ID_AA64ISAR0_SHA2_SHIFT)
+#define	ID_AA64ISAR0_SHA2_MASK		(0xfULL << ID_AA64ISAR0_SHA2_SHIFT)
 #define	ID_AA64ISAR0_SHA2(x)		((x) & ID_AA64ISAR0_SHA2_MASK)
-#define	 ID_AA64ISAR0_SHA2_NONE		(0x0 << ID_AA64ISAR0_SHA2_SHIFT)
+#define	 ID_AA64ISAR0_SHA2_NONE		(0x0ULL << ID_AA64ISAR0_SHA2_SHIFT)
-#define	 ID_AA64ISAR0_SHA2_BASE		(0x1 << ID_AA64ISAR0_SHA2_SHIFT)
+#define	 ID_AA64ISAR0_SHA2_BASE		(0x1ULL << ID_AA64ISAR0_SHA2_SHIFT)
-#define	 ID_AA64ISAR0_SHA2_512		(0x2 << ID_AA64ISAR0_SHA2_SHIFT)
+#define	 ID_AA64ISAR0_SHA2_512		(0x2ULL << ID_AA64ISAR0_SHA2_SHIFT)
 #define	ID_AA64ISAR0_CRC32_SHIFT	16
-#define	ID_AA64ISAR0_CRC32_MASK		(0xf << ID_AA64ISAR0_CRC32_SHIFT)
+#define	ID_AA64ISAR0_CRC32_MASK		(0xfULL << ID_AA64ISAR0_CRC32_SHIFT)
 #define	ID_AA64ISAR0_CRC32(x)		((x) & ID_AA64ISAR0_CRC32_MASK)
-#define	 ID_AA64ISAR0_CRC32_NONE	(0x0 << ID_AA64ISAR0_CRC32_SHIFT)
+#define	 ID_AA64ISAR0_CRC32_NONE	(0x0ULL << ID_AA64ISAR0_CRC32_SHIFT)
-#define	 ID_AA64ISAR0_CRC32_BASE	(0x1 << ID_AA64ISAR0_CRC32_SHIFT)
+#define	 ID_AA64ISAR0_CRC32_BASE	(0x1ULL << ID_AA64ISAR0_CRC32_SHIFT)
 #define	ID_AA64ISAR0_ATOMIC_SHIFT	20
-#define	ID_AA64ISAR0_ATOMIC_MASK	(0xf << ID_AA64ISAR0_ATOMIC_SHIFT)
+#define	ID_AA64ISAR0_ATOMIC_MASK	(0xfULL << ID_AA64ISAR0_ATOMIC_SHIFT)
 #define	ID_AA64ISAR0_ATOMIC(x)		((x) & ID_AA64ISAR0_ATOMIC_MASK)
-#define	 ID_AA64ISAR0_ATOMIC_NONE	(0x0 << ID_AA64ISAR0_ATOMIC_SHIFT)
+#define	 ID_AA64ISAR0_ATOMIC_NONE	(0x0ULL << ID_AA64ISAR0_ATOMIC_SHIFT)
-#define	 ID_AA64ISAR0_ATOMIC_IMPL	(0x2 << ID_AA64ISAR0_ATOMIC_SHIFT)
+#define	 ID_AA64ISAR0_ATOMIC_IMPL	(0x2ULL << ID_AA64ISAR0_ATOMIC_SHIFT)
 #define	ID_AA64ISAR0_RDM_SHIFT		28
-#define	ID_AA64ISAR0_RDM_MASK		(0xf << ID_AA64ISAR0_RDM_SHIFT)
+#define	ID_AA64ISAR0_RDM_MASK		(0xfULL << ID_AA64ISAR0_RDM_SHIFT)
 #define	ID_AA64ISAR0_RDM(x)		((x) & ID_AA64ISAR0_RDM_MASK)
-#define	 ID_AA64ISAR0_RDM_NONE		(0x0 << ID_AA64ISAR0_RDM_SHIFT)
+#define	 ID_AA64ISAR0_RDM_NONE		(0x0ULL << ID_AA64ISAR0_RDM_SHIFT)
-#define	 ID_AA64ISAR0_RDM_IMPL		(0x1 << ID_AA64ISAR0_RDM_SHIFT)
+#define	 ID_AA64ISAR0_RDM_IMPL		(0x1ULL << ID_AA64ISAR0_RDM_SHIFT)
 #define	ID_AA64ISAR0_SHA3_SHIFT		32
 #define	ID_AA64ISAR0_SHA3_MASK		(0xfULL << ID_AA64ISAR0_SHA3_SHIFT)
 #define	ID_AA64ISAR0_SHA3(x)		((x) & ID_AA64ISAR0_SHA3_MASK)
@@ -327,48 +327,48 @@
 /* ID_AA64ISAR1_EL1 */
 #define	ID_AA64ISAR1_MASK		0x00000fffffffffffULL
 #define	ID_AA64ISAR1_DPB_SHIFT		0
-#define	ID_AA64ISAR1_DPB_MASK		(0xf << ID_AA64ISAR1_DPB_SHIFT)
+#define	ID_AA64ISAR1_DPB_MASK		(0xfULL << ID_AA64ISAR1_DPB_SHIFT)
 #define	ID_AA64ISAR1_DPB(x)		((x) & ID_AA64ISAR1_DPB_MASK)
-#define	 ID_AA64ISAR1_DPB_NONE		(0x0 << ID_AA64ISAR1_DPB_SHIFT)
+#define	 ID_AA64ISAR1_DPB_NONE		(0x0ULL << ID_AA64ISAR1_DPB_SHIFT)
-#define	 ID_AA64ISAR1_DPB_IMPL		(0x1 << ID_AA64ISAR1_DPB_SHIFT)
+#define	 ID_AA64ISAR1_DPB_IMPL		(0x1ULL << ID_AA64ISAR1_DPB_SHIFT)
 #define	ID_AA64ISAR1_APA_SHIFT		4
-#define	ID_AA64ISAR1_APA_MASK		(0xf << ID_AA64ISAR1_APA_SHIFT)
+#define	ID_AA64ISAR1_APA_MASK		(0xfULL << ID_AA64ISAR1_APA_SHIFT)
 #define	ID_AA64ISAR1_APA(x)		((x) & ID_AA64ISAR1_APA_MASK)
-#define	 ID_AA64ISAR1_APA_NONE		(0x0 << ID_AA64ISAR1_APA_SHIFT)
+#define	 ID_AA64ISAR1_APA_NONE		(0x0ULL << ID_AA64ISAR1_APA_SHIFT)
-#define	 ID_AA64ISAR1_APA_BASE		(0x1 << ID_AA64ISAR1_APA_SHIFT)
+#define	 ID_AA64ISAR1_APA_BASE		(0x1ULL << ID_AA64ISAR1_APA_SHIFT)
-#define	 ID_AA64ISAR1_APA_PAC		(0x2 << ID_AA64ISAR1_APA_SHIFT)
+#define	 ID_AA64ISAR1_APA_PAC		(0x2ULL << ID_AA64ISAR1_APA_SHIFT)
 #define	ID_AA64ISAR1_API_SHIFT		8
-#define	ID_AA64ISAR1_API_MASK		(0xf << ID_AA64ISAR1_API_SHIFT)
+#define	ID_AA64ISAR1_API_MASK		(0xfULL << ID_AA64ISAR1_API_SHIFT)
 #define	ID_AA64ISAR1_API(x)		((x) & ID_AA64ISAR1_API_MASK)
-#define	 ID_AA64ISAR1_API_NONE		(0x0 << ID_AA64ISAR1_API_SHIFT)
+#define	 ID_AA64ISAR1_API_NONE		(0x0ULL << ID_AA64ISAR1_API_SHIFT)
-#define	 ID_AA64ISAR1_API_BASE		(0x1 << ID_AA64ISAR1_API_SHIFT)
+#define	 ID_AA64ISAR1_API_BASE		(0x1ULL << ID_AA64ISAR1_API_SHIFT)
-#define	 ID_AA64ISAR1_API_PAC		(0x2 << ID_AA64ISAR1_API_SHIFT)
+#define	 ID_AA64ISAR1_API_PAC		(0x2ULL << ID_AA64ISAR1_API_SHIFT)
 #define	ID_AA64ISAR1_JSCVT_SHIFT	12
-#define	ID_AA64ISAR1_JSCVT_MASK		(0xf << ID_AA64ISAR1_JSCVT_SHIFT)
+#define	ID_AA64ISAR1_JSCVT_MASK		(0xfULL << ID_AA64ISAR1_JSCVT_SHIFT)
 #define	ID_AA64ISAR1_JSCVT(x)		((x) & ID_AA64ISAR1_JSCVT_MASK)
-#define	 ID_AA64ISAR1_JSCVT_NONE	(0x0 << ID_AA64ISAR1_JSCVT_SHIFT)
+#define	 ID_AA64ISAR1_JSCVT_NONE	(0x0ULL << ID_AA64ISAR1_JSCVT_SHIFT)
-#define	 ID_AA64ISAR1_JSCVT_IMPL	(0x1 << ID_AA64ISAR1_JSCVT_SHIFT)
+#define	 ID_AA64ISAR1_JSCVT_IMPL	(0x1ULL << ID_AA64ISAR1_JSCVT_SHIFT)
 #define	ID_AA64ISAR1_FCMA_SHIFT		16
-#define	ID_AA64ISAR1_FCMA_MASK		(0xf << ID_AA64ISAR1_FCMA_SHIFT)
+#define	ID_AA64ISAR1_FCMA_MASK		(0xfULL << ID_AA64ISAR1_FCMA_SHIFT)
 #define	ID_AA64ISAR1_FCMA(x)		((x) & ID_AA64ISAR1_FCMA_MASK)
-#define	 ID_AA64ISAR1_FCMA_NONE		(0x0 << ID_AA64ISAR1_FCMA_SHIFT)
+#define	 ID_AA64ISAR1_FCMA_NONE		(0x0ULL << ID_AA64ISAR1_FCMA_SHIFT)
-#define	 ID_AA64ISAR1_FCMA_IMPL		(0x1 << ID_AA64ISAR1_FCMA_SHIFT)
+#define	 ID_AA64ISAR1_FCMA_IMPL		(0x1ULL << ID_AA64ISAR1_FCMA_SHIFT)
 #define	ID_AA64ISAR1_LRCPC_SHIFT	20
-#define	ID_AA64ISAR1_LRCPC_MASK		(0xf << ID_AA64ISAR1_LRCPC_SHIFT)
+#define	ID_AA64ISAR1_LRCPC_MASK		(0xfULL << ID_AA64ISAR1_LRCPC_SHIFT)
 #define	ID_AA64ISAR1_LRCPC(x)		((x) & ID_AA64ISAR1_LRCPC_MASK)
-#define	 ID_AA64ISAR1_LRCPC_NONE	(0x0 << ID_AA64ISAR1_LRCPC_SHIFT)
+#define	 ID_AA64ISAR1_LRCPC_NONE	(0x0ULL << ID_AA64ISAR1_LRCPC_SHIFT)
-#define	 ID_AA64ISAR1_LRCPC_BASE	(0x1 << ID_AA64ISAR1_LRCPC_SHIFT)
+#define	 ID_AA64ISAR1_LRCPC_BASE	(0x1ULL << ID_AA64ISAR1_LRCPC_SHIFT)
-#define	 ID_AA64ISAR1_LRCPC_LDAPUR	(0x2 << ID_AA64ISAR1_LRCPC_SHIFT)
+#define	 ID_AA64ISAR1_LRCPC_LDAPUR	(0x2ULL << ID_AA64ISAR1_LRCPC_SHIFT)
 #define	ID_AA64ISAR1_GPA_SHIFT		24
-#define	ID_AA64ISAR1_GPA_MASK		(0xf << ID_AA64ISAR1_GPA_SHIFT)
+#define	ID_AA64ISAR1_GPA_MASK		(0xfULL << ID_AA64ISAR1_GPA_SHIFT)
 #define	ID_AA64ISAR1_GPA(x)		((x) & ID_AA64ISAR1_GPA_MASK)
-#define	 ID_AA64ISAR1_GPA_NONE		(0x0 << ID_AA64ISAR1_GPA_SHIFT)
+#define	 ID_AA64ISAR1_GPA_NONE		(0x0ULL << ID_AA64ISAR1_GPA_SHIFT)
-#define	 ID_AA64ISAR1_GPA_IMPL		(0x1 << ID_AA64ISAR1_GPA_SHIFT)
+#define	 ID_AA64ISAR1_GPA_IMPL		(0x1ULL << ID_AA64ISAR1_GPA_SHIFT)
 #define	ID_AA64ISAR1_GPI_SHIFT		28
-#define	ID_AA64ISAR1_GPI_MASK		(0xf << ID_AA64ISAR1_GPI_SHIFT)
+#define	ID_AA64ISAR1_GPI_MASK		(0xfULL << ID_AA64ISAR1_GPI_SHIFT)
 #define	ID_AA64ISAR1_GPI(x)		((x) & ID_AA64ISAR1_GPI_MASK)
-#define	 ID_AA64ISAR1_GPI_NONE		(0x0 << ID_AA64ISAR1_GPI_SHIFT)
+#define	 ID_AA64ISAR1_GPI_NONE		(0x0ULL << ID_AA64ISAR1_GPI_SHIFT)
-#define	 ID_AA64ISAR1_GPI_IMPL		(0x1 << ID_AA64ISAR1_GPI_SHIFT)
+#define	 ID_AA64ISAR1_GPI_IMPL		(0x1ULL << ID_AA64ISAR1_GPI_SHIFT)
 #define	ID_AA64ISAR1_FRINTTS_SHIFT	32
 #define	ID_AA64ISAR1_FRINTTS_MASK	(0xfULL << ID_AA64ISAR1_FRINTTS_SHIFT)
 #define	ID_AA64ISAR1_FRINTTS(x)		((x) & ID_AA64ISAR1_FRINTTS_MASK)
@@ -396,95 +396,95 @@
 /* ID_AA64MMFR0_EL1 */
 #define	ID_AA64MMFR0_MASK		0x00000000ffffffffULL
 #define	ID_AA64MMFR0_PA_RANGE_SHIFT	0
-#define	ID_AA64MMFR0_PA_RANGE_MASK	(0xf << ID_AA64MMFR0_PA_RANGE_SHIFT)
+#define	ID_AA64MMFR0_PA_RANGE_MASK	(0xfULL << ID_AA64MMFR0_PA_RANGE_SHIFT)
 #define	ID_AA64MMFR0_PA_RANGE(x)	((x) & ID_AA64MMFR0_PA_RANGE_MASK)
-#define	 ID_AA64MMFR0_PA_RANGE_4G	(0x0 << ID_AA64MMFR0_PA_RANGE_SHIFT)
+#define	 ID_AA64MMFR0_PA_RANGE_4G	(0x0ULL << ID_AA64MMFR0_PA_RANGE_SHIFT)
-#define	 ID_AA64MMFR0_PA_RANGE_64G	(0x1 << ID_AA64MMFR0_PA_RANGE_SHIFT)
+#define	 ID_AA64MMFR0_PA_RANGE_64G	(0x1ULL << ID_AA64MMFR0_PA_RANGE_SHIFT)
-#define	 ID_AA64MMFR0_PA_RANGE_1T	(0x2 << ID_AA64MMFR0_PA_RANGE_SHIFT)
+#define	 ID_AA64MMFR0_PA_RANGE_1T	(0x2ULL << ID_AA64MMFR0_PA_RANGE_SHIFT)
-#define	 ID_AA64MMFR0_PA_RANGE_4T	(0x3 << ID_AA64MMFR0_PA_RANGE_SHIFT)
+#define	 ID_AA64MMFR0_PA_RANGE_4T	(0x3ULL << ID_AA64MMFR0_PA_RANGE_SHIFT)
-#define	 ID_AA64MMFR0_PA_RANGE_16T	(0x4 << ID_AA64MMFR0_PA_RANGE_SHIFT)
+#define	 ID_AA64MMFR0_PA_RANGE_16T	(0x4ULL << ID_AA64MMFR0_PA_RANGE_SHIFT)
-#define	 ID_AA64MMFR0_PA_RANGE_256T	(0x5 << ID_AA64MMFR0_PA_RANGE_SHIFT)
+#define	 ID_AA64MMFR0_PA_RANGE_256T	(0x5ULL << ID_AA64MMFR0_PA_RANGE_SHIFT)
 #define	ID_AA64MMFR0_ASID_BITS_SHIFT	4
-#define	ID_AA64MMFR0_ASID_BITS_MASK	(0xf << ID_AA64MMFR0_ASID_BITS_SHIFT)
+#define	ID_AA64MMFR0_ASID_BITS_MASK	(0xfULL << ID_AA64MMFR0_ASID_BITS_SHIFT)
 #define	ID_AA64MMFR0_ASID_BITS(x)	((x) & ID_AA64MMFR0_ASID_BITS_MASK)
-#define	 ID_AA64MMFR0_ASID_BITS_8	(0x0 << ID_AA64MMFR0_ASID_BITS_SHIFT)
+#define	 ID_AA64MMFR0_ASID_BITS_8	(0x0ULL << ID_AA64MMFR0_ASID_BITS_SHIFT)
-#define	 ID_AA64MMFR0_ASID_BITS_16	(0x2 << ID_AA64MMFR0_ASID_BITS_SHIFT)
+#define	 ID_AA64MMFR0_ASID_BITS_16	(0x2ULL << ID_AA64MMFR0_ASID_BITS_SHIFT)
 #define	ID_AA64MMFR0_BIGEND_SHIFT	8
-#define	ID_AA64MMFR0_BIGEND_MASK	(0xf << ID_AA64MMFR0_BIGEND_SHIFT)
+#define	ID_AA64MMFR0_BIGEND_MASK	(0xfULL << ID_AA64MMFR0_BIGEND_SHIFT)
 #define	ID_AA64MMFR0_BIGEND(x)		((x) & ID_AA64MMFR0_BIGEND_MASK)
-#define	 ID_AA64MMFR0_BIGEND_FIXED	(0x0 << ID_AA64MMFR0_BIGEND_SHIFT)
+#define	 ID_AA64MMFR0_BIGEND_FIXED	(0x0ULL << ID_AA64MMFR0_BIGEND_SHIFT)
-#define	 ID_AA64MMFR0_BIGEND_MIXED	(0x1 << ID_AA64MMFR0_BIGEND_SHIFT)
+#define	 ID_AA64MMFR0_BIGEND_MIXED	(0x1ULL << ID_AA64MMFR0_BIGEND_SHIFT)
 #define	ID_AA64MMFR0_S_NS_MEM_SHIFT	12
-#define	ID_AA64MMFR0_S_NS_MEM_MASK	(0xf << ID_AA64MMFR0_S_NS_MEM_SHIFT)
+#define	ID_AA64MMFR0_S_NS_MEM_MASK	(0xfULL << ID_AA64MMFR0_S_NS_MEM_SHIFT)
 #define	ID_AA64MMFR0_S_NS_MEM(x)	((x) & ID_AA64MMFR0_S_NS_MEM_MASK)
-#define	 ID_AA64MMFR0_S_NS_MEM_NONE	(0x0 << ID_AA64MMFR0_S_NS_MEM_SHIFT)
+#define	 ID_AA64MMFR0_S_NS_MEM_NONE	(0x0ULL << ID_AA64MMFR0_S_NS_MEM_SHIFT)
-#define	 ID_AA64MMFR0_S_NS_MEM_DISTINCT	(0x1 << ID_AA64MMFR0_S_NS_MEM_SHIFT)
+#define	 ID_AA64MMFR0_S_NS_MEM_DISTINCT	(0x1ULL << ID_AA64MMFR0_S_NS_MEM_SHIFT)
 #define	ID_AA64MMFR0_BIGEND_EL0_SHIFT	16
-#define	ID_AA64MMFR0_BIGEND_EL0_MASK	(0xf << ID_AA64MMFR0_BIGEND_EL0_SHIFT)
+#define	ID_AA64MMFR0_BIGEND_EL0_MASK	(0xfULL << ID_AA64MMFR0_BIGEND_EL0_SHIFT)
 #define	ID_AA64MMFR0_BIGEND_EL0(x)	((x) & ID_AA64MMFR0_BIGEND_EL0_MASK)
-#define	 ID_AA64MMFR0_BIGEND_EL0_FIXED	(0x0 << ID_AA64MMFR0_BIGEND_EL0_SHIFT)
+#define	 ID_AA64MMFR0_BIGEND_EL0_FIXED	(0x0ULL << ID_AA64MMFR0_BIGEND_EL0_SHIFT)
-#define	 ID_AA64MMFR0_BIGEND_EL0_MIXED	(0x1 << ID_AA64MMFR0_BIGEND_EL0_SHIFT)
+#define	 ID_AA64MMFR0_BIGEND_EL0_MIXED	(0x1ULL << ID_AA64MMFR0_BIGEND_EL0_SHIFT)
 #define	ID_AA64MMFR0_TGRAN16_SHIFT	20
-#define	ID_AA64MMFR0_TGRAN16_MASK	(0xf << ID_AA64MMFR0_TGRAN16_SHIFT)
+#define	ID_AA64MMFR0_TGRAN16_MASK	(0xfULL << ID_AA64MMFR0_TGRAN16_SHIFT)
 #define	ID_AA64MMFR0_TGRAN16(x)		((x) & ID_AA64MMFR0_TGRAN16_MASK)
-#define	 ID_AA64MMFR0_TGRAN16_NONE	(0x0 << ID_AA64MMFR0_TGRAN16_SHIFT)
+#define	 ID_AA64MMFR0_TGRAN16_NONE	(0x0ULL << ID_AA64MMFR0_TGRAN16_SHIFT)
-#define	 ID_AA64MMFR0_TGRAN16_IMPL	(0x1 << ID_AA64MMFR0_TGRAN16_SHIFT)
+#define	 ID_AA64MMFR0_TGRAN16_IMPL	(0x1ULL << ID_AA64MMFR0_TGRAN16_SHIFT)
 #define	ID_AA64MMFR0_TGRAN64_SHIFT	24
-#define	ID_AA64MMFR0_TGRAN64_MASK	(0xf << ID_AA64MMFR0_TGRAN64_SHIFT)
+#define	ID_AA64MMFR0_TGRAN64_MASK	(0xfULL << ID_AA64MMFR0_TGRAN64_SHIFT)
 #define	ID_AA64MMFR0_TGRAN64(x)		((x) & ID_AA64MMFR0_TGRAN64_MASK)
-#define	 ID_AA64MMFR0_TGRAN64_IMPL	(0x0 << ID_AA64MMFR0_TGRAN64_SHIFT)
+#define	 ID_AA64MMFR0_TGRAN64_IMPL	(0x0ULL << ID_AA64MMFR0_TGRAN64_SHIFT)
-#define	 ID_AA64MMFR0_TGRAN64_NONE	(0xf << ID_AA64MMFR0_TGRAN64_SHIFT)
+#define	 ID_AA64MMFR0_TGRAN64_NONE	(0xfULL << ID_AA64MMFR0_TGRAN64_SHIFT)
 #define	ID_AA64MMFR0_TGRAN4_SHIFT	28
-#define	ID_AA64MMFR0_TGRAN4_MASK	(0xf << ID_AA64MMFR0_TGRAN4_SHIFT)
+#define	ID_AA64MMFR0_TGRAN4_MASK	(0xfULL << ID_AA64MMFR0_TGRAN4_SHIFT)
 #define	ID_AA64MMFR0_TGRAN4(x)		((x) & ID_AA64MMFR0_TGRAN4_MASK)
-#define	 ID_AA64MMFR0_TGRAN4_IMPL	(0x0 << ID_AA64MMFR0_TGRAN4_SHIFT)
+#define	 ID_AA64MMFR0_TGRAN4_IMPL	(0x0ULL << ID_AA64MMFR0_TGRAN4_SHIFT)
-#define	 ID_AA64MMFR0_TGRAN4_NONE	(0xf << ID_AA64MMFR0_TGRAN4_SHIFT)
+#define	 ID_AA64MMFR0_TGRAN4_NONE	(0xfULL << ID_AA64MMFR0_TGRAN4_SHIFT)
 
 /* ID_AA64MMFR1_EL1 */
 #define	ID_AA64MMFR1_MASK		0xf0000000ffffffffULL
 #define	ID_AA64MMFR1_HAFDBS_SHIFT	0
-#define	ID_AA64MMFR1_HAFDBS_MASK	(0xf << ID_AA64MMFR1_HAFDBS_SHIFT)
+#define	ID_AA64MMFR1_HAFDBS_MASK	(0xfULL << ID_AA64MMFR1_HAFDBS_SHIFT)
 #define	ID_AA64MMFR1_HAFDBS(x)		((x) & ID_AA64MMFR1_HAFDBS_MASK)
-#define	 ID_AA64MMFR1_HAFDBS_NONE	(0x0 << ID_AA64MMFR1_HAFDBS_SHIFT)
+#define	 ID_AA64MMFR1_HAFDBS_NONE	(0x0ULL << ID_AA64MMFR1_HAFDBS_SHIFT)
-#define	 ID_AA64MMFR1_HAFDBS_AF		(0x1 << ID_AA64MMFR1_HAFDBS_SHIFT)
+#define	 ID_AA64MMFR1_HAFDBS_AF		(0x1ULL << ID_AA64MMFR1_HAFDBS_SHIFT)
-#define	 ID_AA64MMFR1_HAFDBS_AF_DBS	(0x2 << ID_AA64MMFR1_HAFDBS_SHIFT)
+#define	 ID_AA64MMFR1_HAFDBS_AF_DBS	(0x2ULL << ID_AA64MMFR1_HAFDBS_SHIFT)
 #define	ID_AA64MMFR1_VMIDBITS_SHIFT	4
-#define	ID_AA64MMFR1_VMIDBITS_MASK	(0xf << ID_AA64MMFR1_VMIDBITS_SHIFT)
+#define	ID_AA64MMFR1_VMIDBITS_MASK	(0xfULL << ID_AA64MMFR1_VMIDBITS_SHIFT)
 #define	ID_AA64MMFR1_VMIDBITS(x)	((x) & ID_AA64MMFR1_VMIDBITS_MASK)
-#define	 ID_AA64MMFR1_VMIDBITS_8	(0x0 << ID_AA64MMFR1_VMIDBITS_SHIFT)
+#define	 ID_AA64MMFR1_VMIDBITS_8	(0x0ULL << ID_AA64MMFR1_VMIDBITS_SHIFT)
-#define	 ID_AA64MMFR1_VMIDBITS_16	(0x2 << ID_AA64MMFR1_VMIDBITS_SHIFT)
+#define	 ID_AA64MMFR1_VMIDBITS_16	(0x2ULL << ID_AA64MMFR1_VMIDBITS_SHIFT)
 #define	ID_AA64MMFR1_VH_SHIFT		8
-#define	ID_AA64MMFR1_VH_MASK		(0xf << ID_AA64MMFR1_VH_SHIFT)
+#define	ID_AA64MMFR1_VH_MASK		(0xfULL << ID_AA64MMFR1_VH_SHIFT)
 #define	ID_AA64MMFR1_VH(x)		((x) & ID_AA64MMFR1_VH_MASK)
-#define	 ID_AA64MMFR1_VH_NONE		(0x0 << ID_AA64MMFR1_VH_SHIFT)
+#define	 ID_AA64MMFR1_VH_NONE		(0x0ULL << ID_AA64MMFR1_VH_SHIFT)
-#define	 ID_AA64MMFR1_VH_IMPL		(0x1 << ID_AA64MMFR1_VH_SHIFT)
+#define	 ID_AA64MMFR1_VH_IMPL		(0x1ULL << ID_AA64MMFR1_VH_SHIFT)
 #define	ID_AA64MMFR1_HPDS_SHIFT		12
-#define	ID_AA64MMFR1_HPDS_MASK		(0xf << ID_AA64MMFR1_HPDS_SHIFT)
+#define	ID_AA64MMFR1_HPDS_MASK		(0xfULL << ID_AA64MMFR1_HPDS_SHIFT)
 #define	ID_AA64MMFR1_HPDS(x)		((x) & ID_AA64MMFR1_HPDS_MASK)
-#define	 ID_AA64MMFR1_HPDS_NONE		(0x0 << ID_AA64MMFR1_HPDS_SHIFT)
+#define	 ID_AA64MMFR1_HPDS_NONE		(0x0ULL << ID_AA64MMFR1_HPDS_SHIFT)
-#define	 ID_AA64MMFR1_HPDS_IMPL		(0x1 << ID_AA64MMFR1_HPDS_SHIFT)
+#define	 ID_AA64MMFR1_HPDS_IMPL		(0x1ULL << ID_AA64MMFR1_HPDS_SHIFT)
 #define	ID_AA64MMFR1_LO_SHIFT		16
-#define	ID_AA64MMFR1_LO_MASK		(0xf << ID_AA64MMFR1_LO_SHIFT)
+#define	ID_AA64MMFR1_LO_MASK		(0xfULL << ID_AA64MMFR1_LO_SHIFT)
 #define	ID_AA64MMFR1_LO(x)		((x) & ID_AA64MMFR1_LO_MASK)
-#define	 ID_AA64MMFR1_LO_NONE		(0x0 << ID_AA64MMFR1_LO_SHIFT)
+#define	 ID_AA64MMFR1_LO_NONE		(0x0ULL << ID_AA64MMFR1_LO_SHIFT)
-#define	 ID_AA64MMFR1_LO_IMPL		(0x1 << ID_AA64MMFR1_LO_SHIFT)
+#define	 ID_AA64MMFR1_LO_IMPL		(0x1ULL << ID_AA64MMFR1_LO_SHIFT)
 #define	ID_AA64MMFR1_PAN_SHIFT		20
-#define	ID_AA64MMFR1_PAN_MASK		(0xf << ID_AA64MMFR1_PAN_SHIFT)
+#define	ID_AA64MMFR1_PAN_MASK		(0xfULL << ID_AA64MMFR1_PAN_SHIFT)
 #define	ID_AA64MMFR1_PAN(x)		((x) & ID_AA64MMFR1_PAN_MASK)
-#define	 ID_AA64MMFR1_PAN_NONE		(0x0 << ID_AA64MMFR1_PAN_SHIFT)
+#define	 ID_AA64MMFR1_PAN_NONE		(0x0ULL << ID_AA64MMFR1_PAN_SHIFT)
-#define	 ID_AA64MMFR1_PAN_IMPL		(0x1 << ID_AA64MMFR1_PAN_SHIFT)
+#define	 ID_AA64MMFR1_PAN_IMPL		(0x1ULL << ID_AA64MMFR1_PAN_SHIFT)
-#define	 ID_AA64MMFR1_PAN_ATS1E1	(0x2 << ID_AA64MMFR1_PAN_SHIFT)
+#define	 ID_AA64MMFR1_PAN_ATS1E1	(0x2ULL << ID_AA64MMFR1_PAN_SHIFT)
-#define	 ID_AA64MMFR1_PAN_EPAN		(0x3 << ID_AA64MMFR1_PAN_SHIFT)
+#define	 ID_AA64MMFR1_PAN_EPAN		(0x3ULL << ID_AA64MMFR1_PAN_SHIFT)
 #define	ID_AA64MMFR1_SPECSEI_SHIFT	24
-#define	ID_AA64MMFR1_SPECSEI_MASK	(0xf << ID_AA64MMFR1_SPECSEI_SHIFT)
+#define	ID_AA64MMFR1_SPECSEI_MASK	(0xfULL << ID_AA64MMFR1_SPECSEI_SHIFT)
 #define	ID_AA64MMFR1_SPECSEI(x)		((x) & ID_AA64MMFR1_SPECSEI_MASK)
-#define	 ID_AA64MMFR1_SPECSEI_NONE	(0x0 << ID_AA64MMFR1_SPECSEI_SHIFT)
+#define	 ID_AA64MMFR1_SPECSEI_NONE	(0x0ULL << ID_AA64MMFR1_SPECSEI_SHIFT)
-#define	 ID_AA64MMFR1_SPECSEI_IMPL	(0x1 << ID_AA64MMFR1_SPECSEI_SHIFT)
+#define	 ID_AA64MMFR1_SPECSEI_IMPL	(0x1ULL << ID_AA64MMFR1_SPECSEI_SHIFT)
 #define	ID_AA64MMFR1_XNX_SHIFT		28
-#define	ID_AA64MMFR1_XNX_MASK		(0xf << ID_AA64MMFR1_XNX_SHIFT)
+#define	ID_AA64MMFR1_XNX_MASK		(0xfULL << ID_AA64MMFR1_XNX_SHIFT)
 #define	ID_AA64MMFR1_XNX(x)		((x) & ID_AA64MMFR1_XNX_MASK)
-#define	 ID_AA64MMFR1_XNX_NONE		(0x0 << ID_AA64MMFR1_XNX_SHIFT)
+#define	 ID_AA64MMFR1_XNX_NONE		(0x0ULL << ID_AA64MMFR1_XNX_SHIFT)
-#define	 ID_AA64MMFR1_XNX_IMPL		(0x1 << ID_AA64MMFR1_XNX_SHIFT)
+#define	 ID_AA64MMFR1_XNX_IMPL		(0x1ULL << ID_AA64MMFR1_XNX_SHIFT)
 #define	ID_AA64MMFR1_ECBHB_SHIFT	60
 #define	ID_AA64MMFR1_ECBHB_MASK		(0xfULL << ID_AA64MMFR1_ECBHB_SHIFT)
 #define	ID_AA64MMFR1_ECBHB(x)		((x) & ID_AA64MMFR1_ECBHB_MASK)
@@ -494,43 +494,43 @@
 /* ID_AA64PFR0_EL1 */
 #define	ID_AA64PFR0_MASK		0xff0fffffffffffffULL
 #define	ID_AA64PFR0_EL0_SHIFT		0
-#define	ID_AA64PFR0_EL0_MASK		(0xf << ID_AA64PFR0_EL0_SHIFT)
+#define	ID_AA64PFR0_EL0_MASK		(0xfULL << ID_AA64PFR0_EL0_SHIFT)
 #define	ID_AA64PFR0_EL0(x)		((x) & ID_AA64PFR0_EL0_MASK)
-#define	 ID_AA64PFR0_EL0_64		(1 << ID_AA64PFR0_EL0_SHIFT)
+#define	 ID_AA64PFR0_EL0_64		(0x1ULL << ID_AA64PFR0_EL0_SHIFT)
-#define	 ID_AA64PFR0_EL0_64_32		(2 << ID_AA64PFR0_EL0_SHIFT)
+#define	 ID_AA64PFR0_EL0_64_32		(0x2ULL << ID_AA64PFR0_EL0_SHIFT)
 #define	ID_AA64PFR0_EL1_SHIFT		4
-#define	ID_AA64PFR0_EL1_MASK		(0xf << ID_AA64PFR0_EL1_SHIFT)
+#define	ID_AA64PFR0_EL1_MASK		(0xfULL << ID_AA64PFR0_EL1_SHIFT)
 #define	ID_AA64PFR0_EL1(x)		((x) & ID_AA64PFR0_EL1_MASK)
-#define	 ID_AA64PFR0_EL1_64		(1 << ID_AA64PFR0_EL1_SHIFT)
+#define	 ID_AA64PFR0_EL1_64		(0x1ULL << ID_AA64PFR0_EL1_SHIFT)
-#define	 ID_AA64PFR0_EL1_64_32		(2 << ID_AA64PFR0_EL1_SHIFT)
+#define	 ID_AA64PFR0_EL1_64_32		(0x2ULL << ID_AA64PFR0_EL1_SHIFT)
 #define	ID_AA64PFR0_EL2_SHIFT		8
-#define	ID_AA64PFR0_EL2_MASK		(0xf << ID_AA64PFR0_EL2_SHIFT)
+#define	ID_AA64PFR0_EL2_MASK		(0xfULL << ID_AA64PFR0_EL2_SHIFT)
 #define	ID_AA64PFR0_EL2(x)		((x) & ID_AA64PFR0_EL2_MASK)
-#define	 ID_AA64PFR0_EL2_NONE		(0 << ID_AA64PFR0_EL2_SHIFT)
+#define	 ID_AA64PFR0_EL2_NONE		(0x0ULL << ID_AA64PFR0_EL2_SHIFT)
-#define	 ID_AA64PFR0_EL2_64		(1 << ID_AA64PFR0_EL2_SHIFT)
+#define	 ID_AA64PFR0_EL2_64		(0x1ULL << ID_AA64PFR0_EL2_SHIFT)
-#define	 ID_AA64PFR0_EL2_64_32		(2 << ID_AA64PFR0_EL2_SHIFT)
+#define	 ID_AA64PFR0_EL2_64_32		(0x2ULL << ID_AA64PFR0_EL2_SHIFT)
 #define	ID_AA64PFR0_EL3_SHIFT		12
-#define	ID_AA64PFR0_EL3_MASK		(0xf << ID_AA64PFR0_EL3_SHIFT)
+#define	ID_AA64PFR0_EL3_MASK		(0xfULL << ID_AA64PFR0_EL3_SHIFT)
 #define	ID_AA64PFR0_EL3(x)		((x) & ID_AA64PFR0_EL3_MASK)
-#define	 ID_AA64PFR0_EL3_NONE		(0 << ID_AA64PFR0_EL3_SHIFT)
+#define	 ID_AA64PFR0_EL3_NONE		(0x0ULL << ID_AA64PFR0_EL3_SHIFT)
-#define	 ID_AA64PFR0_EL3_64		(1 << ID_AA64PFR0_EL3_SHIFT)
+#define	 ID_AA64PFR0_EL3_64		(0x1ULL << ID_AA64PFR0_EL3_SHIFT)
-#define	 ID_AA64PFR0_EL3_64_32		(2 << ID_AA64PFR0_EL3_SHIFT)
+#define	 ID_AA64PFR0_EL3_64_32		(0x2ULL << ID_AA64PFR0_EL3_SHIFT)
 #define	ID_AA64PFR0_FP_SHIFT		16
-#define	ID_AA64PFR0_FP_MASK		(0xf << ID_AA64PFR0_FP_SHIFT)
+#define	ID_AA64PFR0_FP_MASK		(0xfULL << ID_AA64PFR0_FP_SHIFT)
 #define	ID_AA64PFR0_FP(x)		((x) & ID_AA64PFR0_FP_MASK)
-#define	 ID_AA64PFR0_FP_IMPL		(0x0 << ID_AA64PFR0_FP_SHIFT)
+#define	 ID_AA64PFR0_FP_IMPL		(0x0ULL << ID_AA64PFR0_FP_SHIFT)
-#define	 ID_AA64PFR0_FP_NONE		(0xf << ID_AA64PFR0_FP_SHIFT)
+#define	 ID_AA64PFR0_FP_NONE		(0xfULL << ID_AA64PFR0_FP_SHIFT)
 #define	ID_AA64PFR0_ADV_SIMD_SHIFT	20
-#define	ID_AA64PFR0_ADV_SIMD_MASK	(0xf << ID_AA64PFR0_ADV_SIMD_SHIFT)
+#define	ID_AA64PFR0_ADV_SIMD_MASK	(0xfULL << ID_AA64PFR0_ADV_SIMD_SHIFT)
 #define	ID_AA64PFR0_ADV_SIMD(x)		((x) & ID_AA64PFR0_ADV_SIMD_MASK)
-#define	 ID_AA64PFR0_ADV_SIMD_IMPL	(0x0 << ID_AA64PFR0_ADV_SIMD_SHIFT)
+#define	 ID_AA64PFR0_ADV_SIMD_IMPL	(0x0ULL << ID_AA64PFR0_ADV_SIMD_SHIFT)
-#define	 ID_AA64PFR0_ADV_SIMD_NONE	(0xf << ID_AA64PFR0_ADV_SIMD_SHIFT)
+#define	 ID_AA64PFR0_ADV_SIMD_NONE	(0xfULL << ID_AA64PFR0_ADV_SIMD_SHIFT)
 #define	ID_AA64PFR0_GIC_BITS		0x4 /* Number of bits in GIC field */
 #define	ID_AA64PFR0_GIC_SHIFT		24
-#define	ID_AA64PFR0_GIC_MASK		(0xf << ID_AA64PFR0_GIC_SHIFT)
+#define	ID_AA64PFR0_GIC_MASK		(0xfULL << ID_AA64PFR0_GIC_SHIFT)
 #define	ID_AA64PFR0_GIC(x)		((x) & ID_AA64PFR0_GIC_MASK)
-#define	 ID_AA64PFR0_GIC_CPUIF_NONE	(0x0 << ID_AA64PFR0_GIC_SHIFT)
+#define	 ID_AA64PFR0_GIC_CPUIF_NONE	(0x0ULL << ID_AA64PFR0_GIC_SHIFT)
-#define	 ID_AA64PFR0_GIC_CPUIF_EN	(0x1 << ID_AA64PFR0_GIC_SHIFT)
+#define	 ID_AA64PFR0_GIC_CPUIF_EN	(0x1ULL << ID_AA64PFR0_GIC_SHIFT)
 #define	ID_AA64PFR0_RAS_SHIFT		28
 #define	ID_AA64PFR0_RAS_MASK		(0xfULL << ID_AA64PFR0_RAS_SHIFT)
 #define	ID_AA64PFR0_RAS(x)		((x) & ID_AA64PFR0_RAS_MASK)
@@ -578,26 +578,26 @@
 /* ID_AA64PFR1_EL1 */
 #define	ID_AA64PFR1_MASK		0x000000000000ffffULL
 #define	ID_AA64PFR1_BT_SHIFT		0
-#define	ID_AA64PFR1_BT_MASK		(0xf << ID_AA64PFR1_BT_SHIFT)
+#define	ID_AA64PFR1_BT_MASK		(0xfULL << ID_AA64PFR1_BT_SHIFT)
 #define	ID_AA64PFR1_BT(x)		((x) & ID_AA64PFR1_BT_MASK)
-#define	 ID_AA64PFR1_BT_NONE		(0 << ID_AA64PFR1_BT_SHIFT)
+#define	 ID_AA64PFR1_BT_NONE		(0x0ULL << ID_AA64PFR1_BT_SHIFT)
-#define	 ID_AA64PFR1_BT_IMPL		(1 << ID_AA64PFR1_BT_SHIFT)
+#define	 ID_AA64PFR1_BT_IMPL		(0x1ULL << ID_AA64PFR1_BT_SHIFT)
 #define	ID_AA64PFR1_SBSS_SHIFT		4
-#define	ID_AA64PFR1_SBSS_MASK		(0xf << ID_AA64PFR1_SBSS_SHIFT)
+#define	ID_AA64PFR1_SBSS_MASK		(0xfULL << ID_AA64PFR1_SBSS_SHIFT)
 #define	ID_AA64PFR1_SBSS(x)		((x) & ID_AA64PFR1_SBSS_MASK)
-#define	 ID_AA64PFR1_SBSS_NONE		(0 << ID_AA64PFR1_SBSS_SHIFT)
+#define	 ID_AA64PFR1_SBSS_NONE		(0x0ULL << ID_AA64PFR1_SBSS_SHIFT)
-#define	 ID_AA64PFR1_SBSS_PSTATE	(1 << ID_AA64PFR1_SBSS_SHIFT)
+#define	 ID_AA64PFR1_SBSS_PSTATE	(0x1ULL << ID_AA64PFR1_SBSS_SHIFT)
-#define	 ID_AA64PFR1_SBSS_PSTATE_MSR	(2 << ID_AA64PFR1_SBSS_SHIFT)
+#define	 ID_AA64PFR1_SBSS_PSTATE_MSR	(0x2ULL << ID_AA64PFR1_SBSS_SHIFT)
 #define	ID_AA64PFR1_MTE_SHIFT		8
-#define	ID_AA64PFR1_MTE_MASK		(0xf << ID_AA64PFR1_MTE_SHIFT)
+#define	ID_AA64PFR1_MTE_MASK		(0xfULL << ID_AA64PFR1_MTE_SHIFT)
 #define	ID_AA64PFR1_MTE(x)		((x) & ID_AA64PFR1_MTE_MASK)
-#define	 ID_AA64PFR1_MTE_NONE		(0 << ID_AA64PFR1_MTE_SHIFT)
+#define	 ID_AA64PFR1_MTE_NONE		(0x0ULL << ID_AA64PFR1_MTE_SHIFT)
-#define	 ID_AA64PFR1_MTE_IMPL		(1 << ID_AA64PFR1_MTE_SHIFT)
+#define	 ID_AA64PFR1_MTE_IMPL		(0x1ULL << ID_AA64PFR1_MTE_SHIFT)
 #define	ID_AA64PFR1_RAS_FRAC_SHIFT	12
-#define	ID_AA64PFR1_RAS_FRAC_MASK	(0xf << ID_AA64PFR1_RAS_FRAC_SHIFT)
+#define	ID_AA64PFR1_RAS_FRAC_MASK	(0xfULL << ID_AA64PFR1_RAS_FRAC_SHIFT)
 #define	ID_AA64PFR1_RAS_FRAC(x)		((x) & ID_AA64PFR1_RAS_FRAC_MASK)
-#define	 ID_AA64PFR1_RAS_FRAC_NONE	(0 << ID_AA64PFR1_RAS_FRAC_SHIFT)
+#define	 ID_AA64PFR1_RAS_FRAC_NONE	(0x0ULL << ID_AA64PFR1_RAS_FRAC_SHIFT)
-#define	 ID_AA64PFR1_RAS_FRAC_IMPL	(1 << ID_AA64PFR1_RAS_FRAC_SHIFT)
+#define	 ID_AA64PFR1_RAS_FRAC_IMPL	(0x1ULL << ID_AA64PFR1_RAS_FRAC_SHIFT)
 
 /* MAIR_EL1 - Memory Attribute Indirection Register */
 #define	MAIR_ATTR_MASK(idx)	(0xff << ((n)* 8))

sys/kern/init_sysent.c

@@ -1,10 +1,10 @@
-/*	$OpenBSD: init_sysent.c,v 1.268 2023/08/20 15:14:20 visa Exp $	*/
+/*	$OpenBSD: init_sysent.c,v 1.269 2023/11/29 20:46:23 bluhm Exp $	*/
 
 /*
  * System call switch table.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from;	OpenBSD: syscalls.master,v 1.250 2023/08/20 15:13:43 visa Exp 
+ * created from;	OpenBSD: syscalls.master,v 1.251 2023/11/29 20:40:06 bluhm Exp 
  */
 
 #include <sys/param.h>
@@ -240,7 +240,7 @@ const struct sysent sysent[] = {
 	    sys_dup3 },				/* 102 = dup3 */
 	{ 1, s(struct sys_sigreturn_args), 0,
 	    sys_sigreturn },			/* 103 = sigreturn */
-	{ 3, s(struct sys_bind_args), 0,
+	{ 3, s(struct sys_bind_args), SY_NOLOCK | 0,
 	    sys_bind },				/* 104 = bind */
 	{ 5, s(struct sys_setsockopt_args), SY_NOLOCK | 0,
 	    sys_setsockopt },			/* 105 = setsockopt */

sys/kern/syscalls.c

@@ -1,10 +1,10 @@
-/*	$OpenBSD: syscalls.c,v 1.266 2023/08/20 15:14:20 visa Exp $	*/
+/*	$OpenBSD: syscalls.c,v 1.267 2023/11/29 20:46:23 bluhm Exp $	*/
 
 /*
  * System call names.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from;	OpenBSD: syscalls.master,v 1.250 2023/08/20 15:13:43 visa Exp 
+ * created from;	OpenBSD: syscalls.master,v 1.251 2023/11/29 20:40:06 bluhm Exp 
  */
 
 const char *const syscallnames[] = {

sys/kern/syscalls.master

@@ -1,4 +1,4 @@
-;	$OpenBSD: syscalls.master,v 1.250 2023/08/20 15:13:43 visa Exp $
+;	$OpenBSD: syscalls.master,v 1.251 2023/11/29 20:40:06 bluhm Exp $
 ;	$NetBSD: syscalls.master,v 1.32 1996/04/23 10:24:21 mycroft Exp $
 
 ;	@(#)syscalls.master	8.2 (Berkeley) 1/13/94
@@ -221,7 +221,7 @@
 101	STD NOLOCK	{ int sys_pipe2(int *fdp, int flags); }
 102	STD NOLOCK	{ int sys_dup3(int from, int to, int flags); }
 103	STD		{ int sys_sigreturn(struct sigcontext *sigcntxp); }
-104	STD		{ int sys_bind(int s, const struct sockaddr *name, \
+104	STD NOLOCK	{ int sys_bind(int s, const struct sockaddr *name, \
 			    socklen_t namelen); }
 105	STD NOLOCK	{ int sys_setsockopt(int s, int level, int name, \
 			    const void *val, socklen_t valsize); }

sys/net/if_vxlan.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: if_vxlan.c,v 1.96 2023/11/28 13:23:20 bluhm Exp $ */
+/*	$OpenBSD: if_vxlan.c,v 1.97 2023/11/29 18:46:37 denis Exp $ */
 
 /*
  * Copyright (c) 2021 David Gwynne <dlg@openbsd.org>
@@ -67,7 +67,6 @@
  * The protocol.
  */
 
-#define VXLANMTU		1492
 #define VXLAN_PORT		4789
 
 struct vxlan_header {

sys/netinet/in_pcb.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: in_pcb.c,v 1.278 2023/11/12 23:19:14 bluhm Exp $	*/
+/*	$OpenBSD: in_pcb.c,v 1.279 2023/11/29 18:30:48 bluhm Exp $	*/
 /*	$NetBSD: in_pcb.c,v 1.25 1996/02/13 23:41:53 christos Exp $	*/
 
 /*
@@ -730,8 +730,7 @@ in_pcbnotifyall(struct inpcbtable *table, struct sockaddr *dst, u_int rtable,
 			continue;
 #endif
 		if (inp->inp_faddr.s_addr != faddr.s_addr ||
-		    rtable_l2(inp->inp_rtableid) != rdomain ||
+		    rtable_l2(inp->inp_rtableid) != rdomain) {
-		    inp->inp_socket == NULL) {
 			continue;
 		}
 		in_pcbref(inp);

sys/netinet/in_pcb.h

@@ -1,4 +1,4 @@
-/*	$OpenBSD: in_pcb.h,v 1.139 2023/11/28 13:23:20 bluhm Exp $	*/
+/*	$OpenBSD: in_pcb.h,v 1.140 2023/11/29 18:30:48 bluhm Exp $	*/
 /*	$NetBSD: in_pcb.h,v 1.14 1996/02/13 23:42:00 christos Exp $	*/
 
 /*
@@ -115,7 +115,7 @@ struct inpcb {
 #define	inp_laddr6	inp_laddru.iau_addr6
 	u_int16_t inp_fport;		/* foreign port */
 	u_int16_t inp_lport;		/* local port */
-	struct	  socket *inp_socket;	/* back pointer to socket */
+	struct	  socket *inp_socket;	/* [I] back pointer to socket */
 	caddr_t	  inp_ppcb;		/* pointer to per-protocol pcb */
 	union {				/* Route (notice increased size). */
 		struct route ru_route;

sys/netinet/tcp_input.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_input.c,v 1.394 2023/11/27 20:37:15 bluhm Exp $	*/
+/*	$OpenBSD: tcp_input.c,v 1.395 2023/11/29 19:19:25 bluhm Exp $	*/
 /*	$NetBSD: tcp_input.c,v 1.23 1996/02/13 23:43:44 christos Exp $	*/
 
 /*
@@ -3360,7 +3360,7 @@ syn_cache_timer(void *arg)
 	 * than the keep alive timer would allow, expire it.
 	 */
 	sc->sc_rxttot += sc->sc_rxtcur;
-	if (sc->sc_rxttot >= tcptv_keep_init)
+	if (sc->sc_rxttot >= READ_ONCE(tcptv_keep_init))
 		goto dropit;
 
 	/* Advance the timer back-off. */
@@ -3867,7 +3867,8 @@ syn_cache_add(struct sockaddr *src, struct sockaddr *dst, struct tcphdr *th,
 		return (-1);
 	}
 	refcnt_init_trace(&sc->sc_refcnt, DT_REFCNT_IDX_SYNCACHE);
-	timeout_set_proc(&sc->sc_timer, syn_cache_timer, sc);
+	timeout_set_flags(&sc->sc_timer, syn_cache_timer, sc,
+	    KCLOCK_NONE, TIMEOUT_PROC | TIMEOUT_MPSAFE);
 
 	/*
 	 * Fill in the cache, and put the necessary IP and TCP

sys/netinet/tcp_subr.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_subr.c,v 1.193 2023/11/26 22:08:10 bluhm Exp $	*/
+/*	$OpenBSD: tcp_subr.c,v 1.194 2023/11/29 18:30:48 bluhm Exp $	*/
 /*	$NetBSD: tcp_subr.c,v 1.22 1996/02/13 23:44:00 christos Exp $	*/
 
 /*
@@ -691,8 +691,7 @@ tcp6_ctlinput(int cmd, struct sockaddr *sa, u_int rdomain, void *d)
 		}
 		if (inp) {
 			seq = ntohl(th.th_seq);
-			if (inp->inp_socket &&
+			if ((tp = intotcpcb(inp)) &&
-			    (tp = intotcpcb(inp)) &&
 			    SEQ_GEQ(seq, tp->snd_una) &&
 			    SEQ_LT(seq, tp->snd_max))
 				notify(inp, inet6ctlerrmap[cmd]);
@@ -816,8 +815,7 @@ tcp_ctlinput(int cmd, struct sockaddr *sa, u_int rdomain, void *v)
 		    rdomain);
 		if (inp) {
 			seq = ntohl(th->th_seq);
-			if (inp->inp_socket &&
+			if ((tp = intotcpcb(inp)) &&
-			    (tp = intotcpcb(inp)) &&
 			    SEQ_GEQ(seq, tp->snd_una) &&
 			    SEQ_LT(seq, tp->snd_max))
 				notify(inp, errno);

sys/netinet/tcp_var.h

@@ -1,4 +1,4 @@
-/*	$OpenBSD: tcp_var.h,v 1.172 2023/11/16 18:27:48 bluhm Exp $	*/
+/*	$OpenBSD: tcp_var.h,v 1.173 2023/11/29 19:19:25 bluhm Exp $	*/
 /*	$NetBSD: tcp_var.h,v 1.17 1996/02/13 23:44:24 christos Exp $	*/
 
 /*
@@ -686,7 +686,7 @@ extern	const struct pr_usrreqs tcp6_usrreqs;
 extern	struct pool tcpcb_pool;
 extern	struct inpcbtable tcbtable;	/* head of queue of active tcpcb's */
 extern	int tcp_do_rfc1323;	/* enabled/disabled? */
-extern	int tcptv_keep_init;	/* time to keep alive the initial SYN packet */
+extern	int tcptv_keep_init;	/* [N] time to keep alive initial SYN packet */
 extern	int tcp_mssdflt;	/* default maximum segment size */
 extern	int tcp_rst_ppslim;	/* maximum outgoing RST packet per second */
 extern	int tcp_ack_on_push;	/* ACK immediately on PUSH */

sys/netinet/udp_usrreq.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: udp_usrreq.c,v 1.309 2023/11/28 13:23:20 bluhm Exp $	*/
+/*	$OpenBSD: udp_usrreq.c,v 1.310 2023/11/29 18:30:48 bluhm Exp $	*/
 /*	$NetBSD: udp_usrreq.c,v 1.28 1996/03/16 23:54:03 christos Exp $	*/
 
 /*
@@ -898,7 +898,7 @@ udp_ctlinput(int cmd, struct sockaddr *sa, u_int rdomain, void *v)
 		inp = in_pcblookup(&udbtable,
 		    ip->ip_dst, uhp->uh_dport, ip->ip_src, uhp->uh_sport,
 		    rdomain);
-		if (inp && inp->inp_socket != NULL)
+		if (inp != NULL)
 			notify(inp, errno);
 		in_pcbunref(inp);
 	} else

sys/netinet6/in6_pcb.c

@@ -1,4 +1,4 @@
-/*	$OpenBSD: in6_pcb.c,v 1.125 2023/11/28 13:23:20 bluhm Exp $	*/
+/*	$OpenBSD: in6_pcb.c,v 1.126 2023/11/29 18:30:48 bluhm Exp $	*/
 
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
@@ -512,14 +512,12 @@ in6_pcbnotify(struct inpcbtable *table, struct sockaddr_in6 *dst,
 		 * as usual.
 		 */
 		if (lport == 0 && fport == 0 && flowinfo &&
-		    inp->inp_socket != NULL &&
 		    flowinfo == (inp->inp_flowinfo & IPV6_FLOWLABEL_MASK) &&
 		    IN6_ARE_ADDR_EQUAL(&inp->inp_laddr6, &sa6_src.sin6_addr))
 			goto do_notify;
 		else if (!IN6_ARE_ADDR_EQUAL(&inp->inp_faddr6,
 					     &dst->sin6_addr) ||
 			 rtable_l2(inp->inp_rtableid) != rdomain ||
-			 inp->inp_socket == NULL ||
 			 (lport && inp->inp_lport != lport) ||
 			 (!IN6_IS_ADDR_UNSPECIFIED(&sa6_src.sin6_addr) &&
 			  !IN6_ARE_ADDR_EQUAL(&inp->inp_laddr6,

sys/sys/syscall.h

@@ -1,10 +1,10 @@
-/*	$OpenBSD: syscall.h,v 1.265 2023/08/20 15:14:20 visa Exp $	*/
+/*	$OpenBSD: syscall.h,v 1.266 2023/11/29 20:46:24 bluhm Exp $	*/
 
 /*
  * System call numbers.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from;	OpenBSD: syscalls.master,v 1.250 2023/08/20 15:13:43 visa Exp
+ * created from;	OpenBSD: syscalls.master,v 1.251 2023/11/29 20:40:06 bluhm Exp
  */
 
 /* syscall: "syscall" ret: "int" args: "int" "..." */

sys/sys/syscallargs.h

@@ -1,10 +1,10 @@
-/*	$OpenBSD: syscallargs.h,v 1.268 2023/08/20 15:14:20 visa Exp $	*/
+/*	$OpenBSD: syscallargs.h,v 1.269 2023/11/29 20:46:24 bluhm Exp $	*/
 
 /*
  * System call argument lists.
  *
  * DO NOT EDIT-- this file is automatically generated.
- * created from;	OpenBSD: syscalls.master,v 1.250 2023/08/20 15:13:43 visa Exp
+ * created from;	OpenBSD: syscalls.master,v 1.251 2023/11/29 20:40:06 bluhm Exp
  */
 
 #ifdef	syscallarg