From 79ac1b21557ec2160907a9199a64919d8fdbfc3f Mon Sep 17 00:00:00 2001
From: El Mostafa IDRASSI <mostafa.idrassi@tutanota.com>
Date: Mon, 17 Oct 2022 17:37:59 +0200
Subject: [PATCH] Re-included support for local machine keys, and added some
 notes about them.

---
 README.md            | 23 +++++---------
 ecdsa.go             | 14 ++++++---
 ecdsa_test.go        | 10 +++---
 examples/csr/main.go |  2 +-
 pcpcrypto.go         | 53 +++++++++++++++++++++----------
 pcpcrypto_test.go    | 75 +++++++++++++++++++++++++++++++++++++-------
 rsa.go               | 14 ++++++---
 rsa_test.go          | 16 +++++-----
 8 files changed, 141 insertions(+), 66 deletions(-)

diff --git a/README.md b/README.md
index d6187ed..89fe910 100644
--- a/README.md
+++ b/README.md
@@ -20,21 +20,14 @@ The pcpCrypto package is installable using go get: `go get github.com/ElMostafaI
 Each PCP-generated TPM key is persistent in regards to the PCP KSP : it has a name and persists
 through reboots. 
 
-In order to achieve this persistence, the PCP KSP creates, for each 
-PCP-generated TPM key, a corresponding file which contains all the information 
-about the public and private parts of the key. For a key that applies to the current user `<username>`, this file resides in 
-`C:\Users\<username>\AppData\Local\Microsoft\Crypto\PCPKSP\<SHA1DIGEST\`, has a name 
-that is the `SHA-1 digest` of the key's name and the extension `PCPKEY`.
-
-This gives the PCP KSP the ability to actually load the key into the TPM's volatile 
-memory at each `NCryptOpenKey` and unload it at each `NCryptFreeObject`, 
-in the manner of a `TPM2-TSS-ENGINE` encrypted blob file.
-
-Therefore, PCP KSP keys are not persistent in regards to the TPM chip itself.
-They are merely transient keys that are created inside of the TPM using 
-`NCryptCreatePersistedKey` and exported immediately into the aforementioned 
-PCP file when `NCryptFinalizeKey` is called. These PCP files will then allow 
-the PCP KSP to reload the key into TPM's volatile memory whenever needed.
+In order to achieve this persistence, the PCP KSP creates, for each PCP-generated TPM key, a corresponding file which contains all the information about the public and private parts of the key. 
+For a key that applies to the current user `<username>`, this file resides in `C:\Users\<username>\AppData\Local\Microsoft\Crypto\PCPKSP\<SHA1DIGEST\`, has a name that is the `SHA-1 digest` of the key's name and the extension `PCPKEY`. 
+For a key that applies to the local machine, this file resides in `C:\ProgramData\Microsoft\Crypto\PCPKSP\<SHA1DIGEST\`, has a name that is the 
+`SHA-1 digest` of the key's name and the extension `PCPKEY`.
+
+This gives the PCP KSP the ability to actually load the key into the TPM's volatile memory at each `NCryptOpenKey` and unload it at each `NCryptFreeObject`, in the manner of a `TPM2-TSS-ENGINE` encrypted blob file.
+
+Therefore, PCP KSP keys are not persistent in regards to the TPM chip itself. They are merely transient keys that are created inside of the TPM using `NCryptCreatePersistedKey` and exported immediately into the aforementioned PCP file when `NCryptFinalizeKey` is called. These PCP files will then allow the PCP KSP to reload the key into TPM's volatile memory whenever needed.
 
 ## Known Limitations
 
diff --git a/ecdsa.go b/ecdsa.go
index fb02d02..c8c0177 100644
--- a/ecdsa.go
+++ b/ecdsa.go
@@ -71,6 +71,9 @@ func (k *pcpECDSAPrivateKey) Sign(rand io.Reader, msg []byte, opts crypto.Signer
 	if k.passwordDigest != nil {
 		openFlags |= internal.NcryptSilentFlag
 	}
+	if k.isLocalMachine {
+		openFlags |= internal.NcryptMachineKeyFlag
+	}
 
 	// Set the other flags
 	// If a password is set for the key, set the flag NCRYPT_SILENT_FLAG, meaning
@@ -144,9 +147,8 @@ func (k *pcpECDSAPrivateKey) Sign(rand io.Reader, msg []byte, opts crypto.Signer
 // GenerateECDSAKey only supports NIST-P256/P384/P521 which are the only curves supported
 // by the PCP KSP (at the time of writing).
 //
-// At the time of writing, and even if we set the NCRYPT_MACHINE_KEY_FLAG flag during
-// creation, the PCP KSP creates a key that applies to the Current User.
-// Therefore, GenerateECDSAKey will always generate keys that apply for the Current User.
+// If isLocalMachine is set to true, GenerateRSAKey will generate keys that apply to the
+// Local Machine. Otherwise, it will generate keys that apply for the Current User.
 //
 // The key usage can be set by combining the following flags using the OR operation :
 //	- KeyUsageAllowDecrypt
@@ -157,7 +159,7 @@ func (k *pcpECDSAPrivateKey) Sign(rand io.Reader, msg []byte, opts crypto.Signer
 // SignOnly for ECDSA keys.
 //
 // TODO: Support UI Policies.
-func GenerateECDSAKey(name string, password string, isUICompatible bool, curve elliptic.Curve, keyUsage uint32, overwrite bool) (Signer, error) {
+func GenerateECDSAKey(name string, password string, isUICompatible bool, isLocalMachine bool, curve elliptic.Curve, keyUsage uint32, overwrite bool) (Signer, error) {
 	var hProvider uintptr
 	var hKey uintptr
 	var creationFlags uint32
@@ -181,6 +183,9 @@ func GenerateECDSAKey(name string, password string, isUICompatible bool, curve e
 	if overwrite {
 		creationFlags |= internal.NcryptOverwriteKeyFlag
 	}
+	if isLocalMachine {
+		creationFlags |= internal.NcryptMachineKeyFlag
+	}
 
 	// Set the other flags
 	if len(password) != 0 {
@@ -299,6 +304,7 @@ func GenerateECDSAKey(name string, password string, isUICompatible bool, curve e
 			passwordDigest: passwordDigest,
 			pubKey:         publicKey,
 			keyUsage:       keyUsage,
+			isLocalMachine: isLocalMachine,
 		},
 	}, nil
 }
diff --git a/ecdsa_test.go b/ecdsa_test.go
index 22d20f9..1d055bc 100644
--- a/ecdsa_test.go
+++ b/ecdsa_test.go
@@ -29,7 +29,7 @@ import (
 func testECDSAGenerateAndFindKey(t *testing.T, name string, password string, isUICompatible bool, curve elliptic.Curve, toBeDeleted bool) {
 
 	// Generate key
-	key, err := GenerateECDSAKey(name, password, isUICompatible, curve, 0, true)
+	key, err := GenerateECDSAKey(name, password, isUICompatible, false, curve, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key)
 	if toBeDeleted {
@@ -40,7 +40,7 @@ func testECDSAGenerateAndFindKey(t *testing.T, name string, password string, isU
 	require.Equal(t, key.Size(), uint32((curve.Params().BitSize+7)/8))
 
 	// Find the key
-	keyBis, err := FindKey(key.Name(), password, isUICompatible)
+	keyBis, err := FindKey(key.Name(), password, isUICompatible, false)
 	require.NoError(t, err)
 	require.NotNil(t, keyBis)
 	require.Equal(t, key.Name(), keyBis.Name())
@@ -96,7 +96,7 @@ func TestECDSAGenerateKey(t *testing.T) {
 func TestECDSASignWithPassNotUICompatible(t *testing.T) {
 
 	// Generate key
-	key, err := GenerateECDSAKey("", "password123", false, elliptic.P256(), 0, true)
+	key, err := GenerateECDSAKey("", "password123", false, false, elliptic.P256(), 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key)
 	defer func() {
@@ -111,7 +111,7 @@ func TestECDSASignWithPassNotUICompatible(t *testing.T) {
 func TestECDSASignWithPassUICompatible(t *testing.T) {
 
 	// Generate key
-	key, err := GenerateECDSAKey("", "password123", true, elliptic.P256(), 0, true)
+	key, err := GenerateECDSAKey("", "password123", true, false, elliptic.P256(), 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key)
 	defer func() {
@@ -159,7 +159,7 @@ func TestECDSASignWithPassUICompatiblePrompt(t *testing.T) {
 func TestECDSASignWithoutPass(t *testing.T) {
 
 	// Generate key
-	key, err := GenerateECDSAKey("", "", false, elliptic.P256(), 0, true)
+	key, err := GenerateECDSAKey("", "", false, false, elliptic.P256(), 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key)
 	defer func() {
diff --git a/examples/csr/main.go b/examples/csr/main.go
index 1960498..edc974e 100644
--- a/examples/csr/main.go
+++ b/examples/csr/main.go
@@ -26,7 +26,7 @@ import (
 )
 
 func main() {
-	key, err := pcpcrypto.GenerateRSAKey("", "", false, 1024, 0, true)
+	key, err := pcpcrypto.GenerateRSAKey("", "", false, false, 1024, 0, true)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "pcpcrypto.GenerateRSAKey() failed: %v\n", err)
 		return
diff --git a/pcpcrypto.go b/pcpcrypto.go
index 822826f..03a1f25 100644
--- a/pcpcrypto.go
+++ b/pcpcrypto.go
@@ -55,6 +55,9 @@ type Signer interface {
 	// KeyUsage returns the PCP key usage.
 	KeyUsage() uint32
 
+	// IsLocalMachine returns whether the key applies to the Local Machine or to the Current User.
+	IsLocalMachine() bool
+
 	// Delete deletes the PCP key.
 	Delete() error
 }
@@ -72,6 +75,7 @@ type pcpPrivateKey struct {
 	passwordDigest []byte           // passwordDigest is the PCP key password / pin digest (SHA-1 if UI compatible, SHA-256 otherwise)
 	pubKey         crypto.PublicKey // pubKey is the public part of the PCP key.
 	keyUsage       uint32           // keyUsage is the PCP key usage.
+	isLocalMachine bool             // isLocalMachine determines whether the key applies to the Local Machine or to the Current User.
 }
 
 // Public is a required method of the crypto.Signer interface.
@@ -89,6 +93,11 @@ func (k pcpPrivateKey) KeyUsage() uint32 {
 	return k.keyUsage
 }
 
+// IsLocalMachine returns whether the key applies to the Local Machine or to the Current User.
+func (k pcpPrivateKey) IsLocalMachine() bool {
+	return k.isLocalMachine
+}
+
 // Delete deletes the PCP key.
 func (k pcpPrivateKey) Delete() error {
 	var hProvider uintptr
@@ -104,6 +113,9 @@ func (k pcpPrivateKey) Delete() error {
 
 	// Set the flags
 	flags = internal.NcryptSilentFlag
+	if k.isLocalMachine {
+		flags |= internal.NcryptMachineKeyFlag
+	}
 
 	// Try to get a handle to the key by its name
 	_, err = internal.NCryptOpenKey(hProvider, &hKey, k.name, 0, flags)
@@ -140,13 +152,12 @@ func (k pcpPrivateKey) Delete() error {
 // Therefore, if isUICompatible is set to true, we will store the SHA-1 of the password,
 // while we will store its SHA-256 if isUICompatible is set to false.
 //
-// At the time of writing, and even if we set the NCRYPT_MACHINE_KEY_FLAG flag during
-// creation, the PCP KSP creates a key that applies to the Current User.
-// Therefore, the search will always look for keys that apply for the Current User.
+// If isLocalMachine is set to true, the search will look for keys that apply to the
+// Local Machine. Otherwise, it will look for keys that apply for the Current User.
 //
 // After all operations are done on the resulting key, its handle should be
 // freed by calling the Close() function on the key.
-func FindKey(name string, password string, isUICompatible bool) (Signer, error) {
+func FindKey(name string, password string, isUICompatible bool, isLocalMachine bool) (Signer, error) {
 	var hProvider uintptr
 	var hKey uintptr
 	var flags uint32
@@ -162,6 +173,9 @@ func FindKey(name string, password string, isUICompatible bool) (Signer, error)
 
 	// Set the flags
 	flags = internal.NcryptSilentFlag
+	if isLocalMachine {
+		flags |= internal.NcryptMachineKeyFlag
+	}
 
 	// Try to get a handle to the key by its name
 	_, err = internal.NCryptOpenKey(hProvider, &hKey, name, 0, flags)
@@ -171,7 +185,7 @@ func FindKey(name string, password string, isUICompatible bool) (Signer, error)
 	defer internal.NCryptFreeObject(hKey)
 
 	// Get key's algorithm
-	algBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptAlgorithmGroupProperty, flags)
+	algBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptAlgorithmGroupProperty, internal.NcryptSilentFlag)
 	if err != nil {
 		return nil, err
 	}
@@ -181,7 +195,7 @@ func FindKey(name string, password string, isUICompatible bool) (Signer, error)
 	}
 
 	// Get key's usage
-	usageBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptKeyUsageProperty, flags)
+	usageBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptKeyUsageProperty, internal.NcryptSilentFlag)
 	if err != nil {
 		return nil, err
 	}
@@ -212,10 +226,10 @@ func FindKey(name string, password string, isUICompatible bool) (Signer, error)
 	var pubkeyBytes []byte
 	var isRSA bool
 	if alg == internal.NcryptRsaAlgorithm {
-		pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptRsapublicBlob, nil, flags)
+		pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptRsapublicBlob, nil, 0)
 		isRSA = true
 	} else if alg == internal.NcryptEcdsaAlgorithm {
-		pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptEccpublicBlob, nil, flags)
+		pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptEccpublicBlob, nil, 0)
 	} else {
 		return nil, fmt.Errorf("unsupported algo: only RSA and ECDSA keys are supported")
 	}
@@ -244,6 +258,7 @@ func FindKey(name string, password string, isUICompatible bool) (Signer, error)
 				passwordDigest: passwordDigest,
 				pubKey:         publicKey,
 				keyUsage:       usage,
+				isLocalMachine: isLocalMachine,
 			},
 		}, nil
 	} else {
@@ -282,6 +297,7 @@ func FindKey(name string, password string, isUICompatible bool) (Signer, error)
 				passwordDigest: passwordDigest,
 				pubKey:         publicKey,
 				keyUsage:       usage,
+				isLocalMachine: isLocalMachine,
 			},
 		}, nil
 	}
@@ -289,11 +305,9 @@ func FindKey(name string, password string, isUICompatible bool) (Signer, error)
 
 // GetKeys tries to retrieve all existing PCP keys.
 //
-// At the time of writing, and even if we set the NCRYPT_MACHINE_KEY_FLAG flag during
-// creation, the PCP KSP creates a key that applies to the Current User.
-// Therefore, GetKeys will always retrieve the keys that apply to the
-// Current User.
-func GetKeys() ([]Signer, error) {
+// If isLocalMachine is set to true, the search will retrieve the keys that apply to the
+// Local Machine. Otherwise, it will retrieve the keys that apply for the Current User.
+func GetKeys(isLocalMachine bool) ([]Signer, error) {
 	var hProvider uintptr
 	var pState unsafe.Pointer
 	var pKeyName unsafe.Pointer
@@ -316,6 +330,9 @@ func GetKeys() ([]Signer, error) {
 
 	// Set the flags
 	flags = internal.NcryptSilentFlag
+	if isLocalMachine {
+		flags |= internal.NcryptMachineKeyFlag
+	}
 
 	// Retrieve 1 key item at a time.
 	for {
@@ -349,7 +366,7 @@ func GetKeys() ([]Signer, error) {
 				defer internal.NCryptFreeObject(hKey)
 
 				// Get key's algorithm
-				algBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptAlgorithmGroupProperty, flags)
+				algBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptAlgorithmGroupProperty, internal.NcryptSilentFlag)
 				if err != nil {
 					return nil, err
 				}
@@ -359,7 +376,7 @@ func GetKeys() ([]Signer, error) {
 				}
 
 				// Get key's usage
-				usageBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptKeyUsageProperty, flags)
+				usageBytes, _, err := internal.NCryptGetProperty(hKey, internal.NcryptKeyUsageProperty, internal.NcryptSilentFlag)
 				if err != nil {
 					return nil, err
 				}
@@ -370,10 +387,10 @@ func GetKeys() ([]Signer, error) {
 
 				// Read key's public part
 				if alg == internal.NcryptRsaAlgorithm {
-					pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptRsapublicBlob, nil, flags)
+					pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptRsapublicBlob, nil, 0)
 					isRSA = true
 				} else if alg == internal.NcryptEcdsaAlgorithm {
-					pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptEccpublicBlob, nil, flags)
+					pubkeyBytes, _, err = internal.NCryptExportKey(hKey, 0, internal.BcryptEccpublicBlob, nil, 0)
 				} else {
 					continue
 				}
@@ -403,6 +420,7 @@ func GetKeys() ([]Signer, error) {
 							passwordDigest: nil,
 							pubKey:         publicKey,
 							keyUsage:       keyUsage,
+							isLocalMachine: isLocalMachine,
 						},
 					})
 				} else {
@@ -441,6 +459,7 @@ func GetKeys() ([]Signer, error) {
 							passwordDigest: nil,
 							pubKey:         publicKey,
 							keyUsage:       keyUsage,
+							isLocalMachine: isLocalMachine,
 						},
 					})
 				}
diff --git a/pcpcrypto_test.go b/pcpcrypto_test.go
index 9982407..b0f29fe 100644
--- a/pcpcrypto_test.go
+++ b/pcpcrypto_test.go
@@ -23,13 +23,61 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestGetKeys(t *testing.T) {
+func TestGetCurrentUserKeys(t *testing.T) {
 	uuidName1, err := uuid.NewRandom()
 	require.NoError(t, err)
 	length := uint32(1024)
 	name1 := uuidName1.String()
-	key1, err := GenerateRSAKey(name1, "", false, length, 0, true)
-	defer key1.Delete()
+	key1, err := GenerateRSAKey(name1, "", false, false, length, 0, true)
+	if key1 != nil {
+		defer key1.Delete()
+	}
+	require.NoError(t, err)
+	require.NotNil(t, key1)
+	require.Equal(t, key1.Name(), name1)
+	require.Equal(t, key1.Size(), (length+7)/8)
+
+	uuidName2, err := uuid.NewRandom()
+	require.NoError(t, err)
+	name2 := uuidName2.String()
+	key2, err := GenerateECDSAKey(name2, "", false, false, elliptic.P256(), 0, true)
+	if key2 != nil {
+		defer key2.Delete()
+	}
+	require.NoError(t, err)
+	require.NotNil(t, key2)
+	require.Equal(t, key2.Name(), name2)
+	require.Equal(t, key2.Size(), uint32((elliptic.P256().Params().BitSize+7)/8))
+
+	foundKey1 := false
+	foundKey2 := false
+	keys, err := GetKeys(false)
+	require.NoError(t, err)
+	for _, key := range keys {
+		if key.Name() == key1.Name() && key.Size() == key1.Size() {
+			foundKey1 = true
+		}
+		if key.Name() == key2.Name() && key.Size() == key2.Size() {
+			foundKey2 = true
+		}
+	}
+	require.Equal(t, foundKey1, true)
+	require.Equal(t, foundKey2, true)
+}
+
+/*
+/* This test requires Admin Privs
+*/
+/*
+func TestLocalMachineKeys(t *testing.T) {
+	uuidName1, err := uuid.NewRandom()
+	require.NoError(t, err)
+	length := uint32(1024)
+	name1 := uuidName1.String()
+	key1, err := GenerateRSAKey(name1, "", false, true, length, 0, true)
+	if key1 != nil {
+		defer key1.Delete()
+	}
 	require.NoError(t, err)
 	require.NotNil(t, key1)
 	require.Equal(t, key1.Name(), name1)
@@ -38,8 +86,10 @@ func TestGetKeys(t *testing.T) {
 	uuidName2, err := uuid.NewRandom()
 	require.NoError(t, err)
 	name2 := uuidName2.String()
-	key2, err := GenerateECDSAKey(name2, "", false, elliptic.P256(), 0, true)
-	defer key2.Delete()
+	key2, err := GenerateECDSAKey(name2, "", false, true, elliptic.P256(), 0, true)
+	if key2 != nil {
+		defer key2.Delete()
+	}
 	require.NoError(t, err)
 	require.NotNil(t, key2)
 	require.Equal(t, key2.Name(), name2)
@@ -47,7 +97,7 @@ func TestGetKeys(t *testing.T) {
 
 	foundKey1 := false
 	foundKey2 := false
-	keys, err := GetKeys()
+	keys, err := GetKeys(true)
 	require.NoError(t, err)
 	for _, key := range keys {
 		if key.Name() == key1.Name() && key.Size() == key1.Size() {
@@ -60,6 +110,7 @@ func TestGetKeys(t *testing.T) {
 	require.Equal(t, foundKey1, true)
 	require.Equal(t, foundKey2, true)
 }
+*/
 
 func TestRSADeleteKey(t *testing.T) {
 
@@ -68,14 +119,14 @@ func TestRSADeleteKey(t *testing.T) {
 	require.NoError(t, err)
 	length := uint32(1024)
 	name := uuidName.String()
-	key, err := GenerateRSAKey(name, "", false, length, 0, true)
+	key, err := GenerateRSAKey(name, "", false, false, length, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key)
 	require.Equal(t, key.Name(), name)
 	require.Equal(t, key.Size(), (length+7)/8)
 
 	// Find the RSA-1024 key
-	keyBis, err := FindKey(name, "", false)
+	keyBis, err := FindKey(name, "", false, false)
 	require.NoError(t, err)
 	require.NotNil(t, keyBis)
 	require.Equal(t, key.Name(), keyBis.Name())
@@ -86,7 +137,7 @@ func TestRSADeleteKey(t *testing.T) {
 	require.NoError(t, key.Delete())
 
 	// Now, it should not be possible to find the RSA-1024 key
-	keyBis, err = FindKey(name, "", false)
+	keyBis, err = FindKey(name, "", false, false)
 	require.Error(t, err)
 	require.Nil(t, keyBis)
 }
@@ -98,14 +149,14 @@ func TestECDSADeleteKey(t *testing.T) {
 	require.NoError(t, err)
 	curve := elliptic.P256()
 	name := uuidName.String()
-	key, err := GenerateECDSAKey(name, "", false, curve, 0, true)
+	key, err := GenerateECDSAKey(name, "", false, false, curve, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key)
 	require.Equal(t, key.Name(), name)
 	require.Equal(t, key.Size(), uint32(((curve.Params().BitSize + 7) / 8)))
 
 	// Find the ECDSA-P256 key
-	keyBis, err := FindKey(name, "", false)
+	keyBis, err := FindKey(name, "", false, false)
 	require.NoError(t, err)
 	require.NotNil(t, keyBis)
 	require.Equal(t, key.Name(), keyBis.Name())
@@ -116,7 +167,7 @@ func TestECDSADeleteKey(t *testing.T) {
 	require.NoError(t, key.Delete())
 
 	// Now, it should not be possible to find the ECDSA-P256 key
-	keyBis, err = FindKey(name, "", false)
+	keyBis, err = FindKey(name, "", false, false)
 	require.Error(t, err)
 	require.Nil(t, keyBis)
 }
diff --git a/rsa.go b/rsa.go
index 2538b75..4bca61f 100644
--- a/rsa.go
+++ b/rsa.go
@@ -70,6 +70,9 @@ func (k *pcpRSAPrivateKey) Sign(rand io.Reader, msg []byte, opts crypto.SignerOp
 	if k.passwordDigest != nil {
 		openFlags |= internal.NcryptSilentFlag
 	}
+	if k.isLocalMachine {
+		openFlags |= internal.NcryptMachineKeyFlag
+	}
 
 	// Set the other flags
 	// If a password is set for the key, set the flag NCRYPT_SILENT_FLAG, meaning
@@ -272,9 +275,8 @@ func signPKCS1v15(priv *pcpRSAPrivateKey, hKey uintptr, msg []byte, hash crypto.
 // Supported RSA bit lengths are dictated by the TPM chip (usually 1024 and 2048)
 // and by the PCP KSP. Therefore, there is no restriction on bitLength by GenerateRSAKey.
 //
-// At the time of writing, and even if we set the NCRYPT_MACHINE_KEY_FLAG flag during
-// creation, the PCP KSP creates a key that applies to the Current User.
-// Therefore, GenerateRSAKey will always generate keys that apply for the Current User.
+// If isLocalMachine is set to true, GenerateRSAKey will generate keys that apply to the
+// Local Machine. Otherwise, it will generate keys that apply for the Current User.
 //
 // The key usage can be set by combining the following flags using the OR operation :
 //	- KeyUsageAllowDecrypt
@@ -285,7 +287,7 @@ func signPKCS1v15(priv *pcpRSAPrivateKey, hKey uintptr, msg []byte, hash crypto.
 // Sign + Decrypt for RSA keys.
 //
 // TODO: Support UI Policies.
-func GenerateRSAKey(name string, password string, isUICompatible bool, bitLength uint32, keyUsage uint32, overwrite bool) (Signer, error) {
+func GenerateRSAKey(name string, password string, isUICompatible bool, isLocalMachine bool, bitLength uint32, keyUsage uint32, overwrite bool) (Signer, error) {
 	var hProvider uintptr
 	var hKey uintptr
 	var creationFlags uint32
@@ -309,6 +311,9 @@ func GenerateRSAKey(name string, password string, isUICompatible bool, bitLength
 	if overwrite {
 		creationFlags |= internal.NcryptOverwriteKeyFlag
 	}
+	if isLocalMachine {
+		creationFlags |= internal.NcryptMachineKeyFlag
+	}
 
 	// Set the other flags
 	if len(password) != 0 {
@@ -409,6 +414,7 @@ func GenerateRSAKey(name string, password string, isUICompatible bool, bitLength
 			passwordDigest: passwordDigest,
 			pubKey:         publicKey,
 			keyUsage:       keyUsage,
+			isLocalMachine: isLocalMachine,
 		},
 	}, nil
 }
diff --git a/rsa_test.go b/rsa_test.go
index 727e77a..5fa5570 100644
--- a/rsa_test.go
+++ b/rsa_test.go
@@ -27,7 +27,7 @@ import (
 func testRSAGenerateAndFindKey(t *testing.T, name string, password string, isUICompatible bool, length uint32, toBeDeleted bool) {
 
 	// Generate key
-	key, err := GenerateRSAKey(name, password, isUICompatible, length, 0, true)
+	key, err := GenerateRSAKey(name, password, isUICompatible, false, length, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key)
 	if toBeDeleted {
@@ -38,7 +38,7 @@ func testRSAGenerateAndFindKey(t *testing.T, name string, password string, isUIC
 	require.Equal(t, key.Size(), (length+7)/8)
 
 	// Find the key
-	keyBis, err := FindKey(key.Name(), password, isUICompatible)
+	keyBis, err := FindKey(key.Name(), password, isUICompatible, false)
 	require.NoError(t, err)
 	require.NotNil(t, keyBis)
 	require.Equal(t, key.Name(), keyBis.Name())
@@ -139,7 +139,7 @@ func TestRSAGenerateKey(t *testing.T) {
 func TestRSASignWithPassNotUICompatible(t *testing.T) {
 
 	// Generate key
-	key1024, err := GenerateRSAKey("", "password123", false, 1024, 0, true)
+	key1024, err := GenerateRSAKey("", "password123", false, false, 1024, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key1024)
 	defer func() {
@@ -166,7 +166,7 @@ func TestRSASignWithPassNotUICompatible(t *testing.T) {
 	t.Run("RSASIGNPKCS-1024-SHA512", func(t *testing.T) { testRSASignDigestPKCS1v15(t, key1024, crypto.SHA512) })
 
 	// Generate key
-	key2048, err := GenerateRSAKey("", "password123", false, 2048, 0, true)
+	key2048, err := GenerateRSAKey("", "password123", false, false, 2048, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key2048)
 	defer func() {
@@ -196,7 +196,7 @@ func TestRSASignWithPassNotUICompatible(t *testing.T) {
 func TestRSASignWithPassUICompatible(t *testing.T) {
 
 	// Generate key
-	key1024, err := GenerateRSAKey("", "password123", true, 1024, 0, true)
+	key1024, err := GenerateRSAKey("", "password123", true, false, 1024, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key1024)
 	defer func() {
@@ -223,7 +223,7 @@ func TestRSASignWithPassUICompatible(t *testing.T) {
 	t.Run("RSASIGNPKCS-1024-SHA512", func(t *testing.T) { testRSASignDigestPKCS1v15(t, key1024, crypto.SHA512) })
 
 	// Generate key
-	key2048, err := GenerateRSAKey("", "password123", true, 2048, 0, true)
+	key2048, err := GenerateRSAKey("", "password123", true, false, 2048, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key2048)
 	defer func() {
@@ -335,7 +335,7 @@ func TestRSASignWithPassUICompatiblePrompt(t *testing.T) {
 func TestRSASignWithoutPass(t *testing.T) {
 
 	// Generate key
-	key1024, err := GenerateRSAKey("", "", false, 1024, 0, true)
+	key1024, err := GenerateRSAKey("", "", false, false, 1024, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key1024)
 	defer func() {
@@ -362,7 +362,7 @@ func TestRSASignWithoutPass(t *testing.T) {
 	t.Run("RSASIGNPKCS-1024-SHA512", func(t *testing.T) { testRSASignDigestPKCS1v15(t, key1024, crypto.SHA512) })
 
 	// Generate key
-	key2048, err := GenerateRSAKey("", "", false, 2048, 0, true)
+	key2048, err := GenerateRSAKey("", "", false, false, 2048, 0, true)
 	require.NoError(t, err)
 	require.NotNil(t, key2048)
 	defer func() {