microsoft-identity-web/tests/Microsoft.Identity.Web.Test/Certificates/CertificateDescriptionTests.cs at 4615bed22ed382a05d73f2c0f8d54e6767010d99 · AzureAD/microsoft-identity-web · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using System.Security.Cryptography.X509Certificates;
using Xunit;

namespace Microsoft.Identity.Web.Test.Certificates
{
    public class CertificateDescriptionTests
    {
        [Theory]
        [InlineData("https://vaultname.vault.azure.net/certificates/certificateid/3fb1c62f74b844b0a2d9f1a3d289648d", "certificateName")]
        public void TestFromKeyVault(string keyVaultUrl, string certificateName)
        {
            CertificateDescription certificateDescription = CertificateDescription.FromKeyVault(keyVaultUrl, certificateName);
            Assert.Equal(CertificateSource.KeyVault, certificateDescription.SourceType);
            Assert.Equal(keyVaultUrl, certificateDescription.Container);
            Assert.Equal(certificateName, certificateDescription.ReferenceOrValue);
            Assert.Equal(certificateName, certificateDescription.KeyVaultCertificateName);
            Assert.Equal(keyVaultUrl, certificateDescription.KeyVaultUrl);
#if NET462
            Assert.Equal(X509KeyStorageFlags.MachineKeySet, certificateDescription.X509KeyStorageFlags);
#else
            Assert.Equal(X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.EphemeralKeySet, certificateDescription.X509KeyStorageFlags);
#endif
            certificateDescription.X509KeyStorageFlags = X509KeyStorageFlags.UserKeySet;
            Assert.Equal(X509KeyStorageFlags.UserKeySet, certificateDescription.X509KeyStorageFlags);
        }

        [Theory]
        [InlineData(@"C:\Users\myname\Documents\TestJWE.pfx", "TestJWE")]
        public void TestFromPath(string certificatePath, string password)
        {
            CertificateDescription certificateDescription = CertificateDescription.FromPath(certificatePath, password);
            Assert.Equal(CertificateSource.Path, certificateDescription.SourceType);
            Assert.Equal(certificatePath, certificateDescription.Container);
            Assert.Equal(password, certificateDescription.ReferenceOrValue);
            Assert.Equal(certificatePath, certificateDescription.CertificateDiskPath);
            Assert.Equal(password, certificateDescription.CertificatePassword);
        }

        [Theory]
        [InlineData("440A5BE6C4BE2FF02A0ADBED1AAA43D6CF12E269")]
        public void TestFromBase64Encoded(string base64Encoded)
        {
            CertificateDescription certificateDescription = CertificateDescription.FromBase64Encoded(base64Encoded);
            Assert.Equal(CertificateSource.Base64Encoded, certificateDescription.SourceType);
            Assert.Equal(base64Encoded, certificateDescription.ReferenceOrValue);
            Assert.Equal(base64Encoded, certificateDescription.Base64EncodedValue);
        }

        [Theory]
        [InlineData("CN=TestCert", StoreLocation.LocalMachine, StoreName.Root)]
        public void TestFromCertificateDistinguishedName(string certificateDistinguishedName, StoreLocation storeLocation, StoreName storeName)
        {
            CertificateDescription certificateDescription =
                CertificateDescription.FromStoreWithDistinguishedName(certificateDistinguishedName, storeLocation, storeName);
            Assert.Equal(CertificateSource.StoreWithDistinguishedName, certificateDescription.SourceType);
            Assert.Equal($"{storeLocation}/{storeName}", certificateDescription.Container);
            Assert.Equal(certificateDistinguishedName, certificateDescription.ReferenceOrValue);
            Assert.Equal(certificateDistinguishedName, certificateDescription.CertificateDistinguishedName);
            Assert.Equal($"{storeLocation}/{storeName}", certificateDescription.CertificateStorePath);
        }

        [Theory]
        [InlineData("440A5BE6", StoreLocation.LocalMachine, StoreName.Root)]
        public void TestFromStoreWithThumbprint(string certificateThumbprint, StoreLocation storeLocation, StoreName storeName)
        {
            CertificateDescription certificateDescription =
                CertificateDescription.FromStoreWithThumbprint(certificateThumbprint, storeLocation, storeName);
            Assert.Equal(CertificateSource.StoreWithThumbprint, certificateDescription.SourceType);
            Assert.Equal($"{storeLocation}/{storeName}", certificateDescription.Container);
            Assert.Equal(certificateThumbprint, certificateDescription.ReferenceOrValue);
            Assert.Equal($"{storeLocation}/{storeName}", certificateDescription.CertificateStorePath);
            Assert.Equal(certificateThumbprint, certificateDescription.CertificateThumbprint);
        }

        [Fact]
        public void TestFromCertificate()
        {
            using X509Certificate2 certificate2 = new X509Certificate2(new byte[0]);
            CertificateDescription certificateDescription =
                CertificateDescription.FromCertificate(certificate2);
        }
    }
}