DSInternals/Src/DSInternals.Common/Data/DPAPI/DPAPIBackupKey.cs

namespace DSInternals.Common.Data
{
    using DSInternals.Common.Cryptography;
    using System;
    using System.IO;
    using System.Security.Cryptography;
    using System.Security.Cryptography.X509Certificates;
    using System.Text.RegularExpressions;

    public class DPAPIBackupKey : DPAPIObject
    {
        private const int KeyVersionOffset = 0;
        private const int KeyVersionSize = sizeof(int);
        private const int RSAPrivateKeySizeOffset = KeyVersionOffset + KeyVersionSize;
        private const int RSACertificateSizeOffset = RSAPrivateKeySizeOffset + sizeof(int);
        private const int RSAPrivateKeyOffset = RSACertificateSizeOffset + sizeof(int);
        private const string BackupKeyDNFormat = "CN=BCKUPKEY_{0} Secret,CN=System,{1}";
        private const string BackupKeyDNRegex = "CN=BCKUPKEY_(.*) Secret,CN=System,.*";
        private const string PreferredLegacyKeyPointerName = "P";
        private const string PreferredRSAKeyPointerName = "PREFERRED";
        private const string TemporaryKeyContainerName = "DSInternals";
        private const string RSAKeyFileNameFormat = "ntds_capi_{0}.pvk";
        private const string RSACertFileNameFormat = "ntds_capi_{0}.cer";
        private const string RSAP12FileNameFormat = "ntds_capi_{0}.pfx";
        private const string LegacyKeyFileNameFormat = "ntds_legacy_{0}.key";
        private const string UnknownKeyFileNameFormat = "ntds_unknown_{0}_{1}.key";
        private const string KiwiCommandFormat = "REM Add this parameter to at least the first dpapi::masterkey command: /pvk:\"{0}\"";
        private const int PVKHeaderSize = 6 * sizeof(int);
        private const uint PVKHeaderMagic = 0xb0b5f11e;
        private const uint PVKHeaderVersion = 0;
        private const uint PVKHeaderKeySpec = 1; // = AT_KEYEXCHANGE

        public DPAPIBackupKey(DirectoryObject dsObject, DirectorySecretDecryptor pek)
        {
            // Parameter validation
            Validator.AssertNotNull(dsObject, "dsObject");
            Validator.AssertNotNull(pek, "pek");
            // TODO: Test Object type

            // Decrypt the secret value
            byte[] encryptedSecret;
            dsObject.ReadAttribute(CommonDirectoryAttributes.CurrentValue, out encryptedSecret);
            byte[] decryptedBlob = pek.DecryptSecret(encryptedSecret);

            // Initialize properties
            this.Initialize(dsObject.DistinguishedName, decryptedBlob);
        }

        public DPAPIBackupKey(string distinguishedName, byte[] blob)
        {
            // Validate the input
            Validator.AssertNotNullOrWhiteSpace(distinguishedName, "distinguishedName");
            Validator.AssertNotNull(blob, "blob");

            this.Initialize(distinguishedName, blob);
        }

        public override string FilePath
        {
            get
            {
                switch(this.Type)
                {
                    case DPAPIBackupKeyType.RSAKey:
                        // .pvk file
                        return String.Format(RSAKeyFileNameFormat, this.KeyId);
                    case DPAPIBackupKeyType.LegacyKey:
                        // .key file
                        return String.Format(LegacyKeyFileNameFormat, this.KeyId);
                    case DPAPIBackupKeyType.Unknown:
                        // Generate an additional random ID to prevent potential filename conflicts
                        int rnd = new Random().Next();
                        return String.Format(UnknownKeyFileNameFormat, this.KeyId, rnd);
                    default:
                        // Saving pointers or other domain key types to files is not supported.
                        return null;
                }
            }
        }

        public override string KiwiCommand
        {
            get
            {
                return this.Type == DPAPIBackupKeyType.RSAKey ? String.Format(KiwiCommandFormat, this.FilePath) : null;
            }
        }

        public DPAPIBackupKeyType Type
        {
            get;
            private set;
        }
        public string DistinguishedName
        {
            get;
            private set;
        }

        public Guid KeyId
        {
            get;
            private set;
        }

        public override void Save(string directoryPath)
        {
            // The target directory must exist
            Validator.AssertDirectoryExists(directoryPath);

            string fullFilePath;

            switch (this.Type)
            {
                case DPAPIBackupKeyType.RSAKey:
                    // Parse the public and private keys
                    int privateKeySize = BitConverter.ToInt32(this.Data, RSAPrivateKeySizeOffset);
                    int certificateSize = BitConverter.ToInt32(this.Data, RSACertificateSizeOffset);
                    
                    byte[] privateKey = this.Data.Cut(RSAPrivateKeyOffset, privateKeySize);
                    byte[] certificate = this.Data.Cut(RSAPrivateKeyOffset + privateKeySize, certificateSize);
                    
                    // Create PVK file
                    fullFilePath = Path.Combine(directoryPath, this.FilePath);
                    byte[] pvk = EncapsulatePvk(privateKey);
                    File.WriteAllBytes(fullFilePath, pvk);

                    // Create PFX file
                    byte[] pkcs12 = CreatePfx(certificate, privateKey);
                    var pfxFile = String.Format(RSAP12FileNameFormat, this.KeyId);
                    fullFilePath = Path.Combine(directoryPath, pfxFile);
                    File.WriteAllBytes(fullFilePath, pkcs12);

                    // Create CER file
                    var cerFile = String.Format(RSACertFileNameFormat, this.KeyId);
                    fullFilePath = Path.Combine(directoryPath, cerFile);
                    File.WriteAllBytes(fullFilePath, certificate);
                    break;
                case DPAPIBackupKeyType.LegacyKey:
                    // We create one KEY file, while cropping out the key version.
                    fullFilePath = Path.Combine(directoryPath, this.FilePath);
                    File.WriteAllBytes(fullFilePath, this.Data.Cut(KeyVersionSize));
                    break;
                case DPAPIBackupKeyType.Unknown:
                    fullFilePath = Path.Combine(directoryPath, this.FilePath);
                    File.WriteAllBytes(fullFilePath, this.Data);
                    break;
                case DPAPIBackupKeyType.PreferredLegacyKeyPointer:
                case DPAPIBackupKeyType.PreferredRSAKeyPointer:
                default:
                    // Do not save these pointer keys
                    break;
            }
        }

        /// <summary>
        /// Object initializer that is shared between multiple constructors.
        /// </summary>
        /// <param name="distinguishedName">Distinguished name of the DPAPI backup key object.</param>
        /// <param name="blob">Decrypted data blob.</param>
        private void Initialize(string distinguishedName, byte[] blob)
        {
            this.DistinguishedName = distinguishedName;
            this.Data = blob;

            // Parse DN to get key ID or pointer type:
            var keyName = GetSecretNameFromDN(distinguishedName);
            switch (keyName)
            {
                case null:
                    // We could not parse the DN, so exit with Unknown as the key type
                    this.Type = DPAPIBackupKeyType.Unknown;
                    break;
                case PreferredRSAKeyPointerName:
                    this.Type = DPAPIBackupKeyType.PreferredRSAKeyPointer;
                    // Interpret the raw data as Guid
                    this.KeyId = new Guid(blob);
                    break;
                case PreferredLegacyKeyPointerName:
                    this.Type = DPAPIBackupKeyType.PreferredLegacyKeyPointer;
                    // Interpret the raw data as Guid
                    this.KeyId = new Guid(blob);
                    break;
                default:
                    // Actual Key, so we parse its Guid and version
                    this.KeyId = Guid.Parse(keyName);
                    this.Type = (DPAPIBackupKeyType)BitConverter.ToInt32(blob, KeyVersionOffset);
                    break;
            }
        }

        public static string GetKeyDN(Guid keyId, string domainDN)
        {
            return String.Format(BackupKeyDNFormat, keyId, domainDN);
        }

        public static string GetPreferredRSAKeyPointerDN(string domainDN)
        {
            return String.Format(BackupKeyDNFormat, PreferredRSAKeyPointerName, domainDN);
        }

        public static string GetPreferredLegacyKeyPointerDN(string domainDN)
        {
            return String.Format(BackupKeyDNFormat, PreferredLegacyKeyPointerName, domainDN);
        }

        private static string GetSecretNameFromDN(string distinguishedName)
        {
            var match = Regex.Match(distinguishedName, BackupKeyDNRegex);
            bool success = match.Success && (match.Groups.Count == 2);
            return success ? match.Groups[1].Value : null;
        }

        private static byte[] CreatePfx(byte[] certificate, byte[] privateKey)
        {
            // The PFX export only works if the key is stored in a named container
            var cspParameters = new CspParameters();
            cspParameters.KeyContainerName = TemporaryKeyContainerName;
            using (var keyContainer = new RSACryptoServiceProvider(cspParameters))
            {
                // Make the key temporary
                keyContainer.PersistKeyInCsp = false;
                keyContainer.ImportCspBlob(privateKey);
                // Combine the private and public keys
                var combinedCertificate = new X509Certificate2(certificate);
                combinedCertificate.PrivateKey = keyContainer;
                // Convert to binary PFX
                return combinedCertificate.Export(X509ContentType.Pfx);
            }
        }

        private static byte[] EncapsulatePvk(byte[] privateKey)
        {
            // We do a quick and dirty encapsulation of the private key into the PVK format.
            // See: http://www.drh-consultancy.demon.co.uk/pvk.html
            // TODO: Extract PVK code to a distinct class.
            int pvkSize = PVKHeaderSize + privateKey.Length;
            byte[] pvk = new byte[pvkSize];

            using (var stream = new MemoryStream(pvk, true))
            {
                using (var writer = new BinaryWriter(stream))
                {
                    // Write PVK header
                    writer.Write(PVKHeaderMagic);
                    writer.Write(PVKHeaderVersion);
                    writer.Write(PVKHeaderKeySpec);
                    writer.Write((int)PrivateKeyEncryptionType.None);
                    writer.Write((int)0); // Size of salt 
                    writer.Write(privateKey.Length);

                    // Write the actual data
                    writer.Write(privateKey);
                }
            }

            return pvk;
        }
    }
}