示例#1
0
        /// <summary>
        /// ProcessRecord
        /// </summary>
        protected override void ProcessRecord()
        {
            Data.KeyVault KeyVault = KeyVaultHelper.GetItemThrow(null, VaultName, true);

            if (!(String.IsNullOrEmpty(KeyVault.Thumbprint)))
            {
                WriteError(
                    (new PSAdminException(PSAdminExceptionType.ParameterDefined, String.Format("in KeyVault '{0}' with the name of '{1}'", VaultName, Thumbprint))).GetErrorRecord()
                    );
                return;
            }

            Data.KeyVaultCertificate[] SearchCertificate = KeyVaultCertificateHelper.GetItemsThrow(null, KeyVault.VaultName, null, Thumbprint, null, false, true);

            X509Certificate2 x509 = (X509Certificate2)SearchCertificate[0].Certificate;

            if ((x509.HasPrivateKey == false) || (x509.PrivateKey == null))
            {
                WriteError(
                    (new PSAdminException(PSAdminExceptionType.CertificatePrivateKey, Thumbprint)).GetErrorRecord()
                    );
                return;
            }

            Hashtable filter = new Hashtable {
                { "Id", KeyVault.Id },
                { "VaultName", KeyVault.VaultName },
            };
            Hashtable row = new Hashtable {
                { "Thumbprint", x509.Thumbprint },
                { "VaultKey", ((RSACryptoServiceProvider)x509.PublicKey.Key).Encrypt(KeyVault.VaultKey, true) }
            };

            bool issuccessful = KeyVaultHelper.SetItemsThrow(row, filter, true);
        }
示例#2
0
        /// <summary>
        /// Process Record
        /// </summary>
        protected override void ProcessRecord()
        {
            Data.KeyVault KeyVault = KeyVaultHelper.GetItemThrow(null, VaultName, true);

            Data.KeyVaultCertificate[] SearchCertificate = KeyVaultCertificateHelper.GetItemsThrow(null, VaultName, Name, null, null, false, true);

            // Note: This will only ever return one item
            foreach (Data.KeyVaultCertificate Certificate in SearchCertificate)
            {
                X509Certificate2 x509 = (X509Certificate2)Certificate.Certificate;
                byte[]           CertificateByteArray = x509.Export(X509ContentType.Pkcs12, Password);
                x509.Dispose();
                switch (ParameterSetName)
                {
                case ImportFromFileParameterSetName:
                    File.WriteAllBytes(FileName, CertificateByteArray);
                    break;

                case ImportFromStringParameterSetName:
                    WriteObject(
                        Convert.ToBase64String(CertificateByteArray)
                        );
                    break;

                default:
                    WriteError(
                        (new PSAdminException(PSAdminExceptionType.ParameterSetNotFound, Name, "Name")).GetErrorRecord()
                        );
                    return;
                }
            }
        }
示例#3
0
 public static bool RemoveItem(string Id, string VaultName, bool Exact)
 {
     Data.KeyVault result = GetItem(Id, VaultName, Exact);
     if (result == null) {
         return false;
     }
     return RemoveItems(Id, VaultName, Exact);
 }
示例#4
0
 internal static bool SetItemThrow(string Id, string VaultName, string Location, string VaultURI, bool SoftDeleteEnabled, string[] Tags, bool Exact)
 {
     Data.KeyVault result = GetItemThrow(Id, VaultName, Exact);
     if (result == null) {
         return false;
     }
     return SetItemsThrow(Id, VaultName, Location, VaultURI, SoftDeleteEnabled, Tags, Exact);
 }
示例#5
0
文件: KeyVault.cs 项目: M1kep/PSAdmin
        /// <summary>
        /// Process Record
        /// </summary>
        protected override void ProcessRecord()
        {
            String Id = Guid.NewGuid().ToString().Replace("-", "");

            KeyVaultHelper.NewItemThrow(Id, VaultName, Location, VaultURI, SoftDeleteEnabled, Tags);

            if (Passthru)
            {
                Data.KeyVault result = KeyVaultHelper.GetItem(null, VaultName, true);
                WriteObject(result);
            }
        }
示例#6
0
        internal static byte[] GetVaultKey(string VaultName)
        {
            Data.KeyVault KeyVault = KeyVaultHelper.GetItemThrow(null, VaultName, true);

            if ( String.IsNullOrEmpty(KeyVault.Thumbprint) )
                return KeyVault.VaultKey;

            Data.KeyVaultCertificate Certificate = KeyVaultCertificateHelper.GetItemThrow(null, VaultName, null, KeyVault.Thumbprint, null, true, true);

            // Decrypt the Key
            X509Certificate2 x509 = (X509Certificate2)Certificate.Certificate;

            if ((x509.HasPrivateKey == false) || (x509.PrivateKey == null))
            {
                throw new InvalidOperationException("Certificate does not contain PrivateKey");
            }
            return ((RSACryptoServiceProvider)x509.PrivateKey).Decrypt(KeyVault.VaultKey, true);
        }
示例#7
0
        public static bool SetItems(string Id, string VaultName, string Name, string Version, string Enabled, Nullable <DateTime> Expires, Nullable <DateTime> NotBefore, string ContentType, string[] Tags, string SecretValue, bool Exact)
        {
            Data.KeyVault KeyVault = KeyVaultHelper.GetItem(null, VaultName, true);
            if (KeyVault == null)
            {
                return(false);
            }

            // Build the Key
            byte[] Key        = KeyVaultHelper.GetVaultKey(KeyVault.VaultName);
            byte[] SecretData = null;
            if (!String.IsNullOrEmpty(SecretValue))
            {
                SecretData = Crypto.ConvertToKeyVaultSecret(SecretValue, Key);
            }

            Hashtable filter = new Hashtable {
                { "Id", Id },
                { "VaultName", VaultName },
                { "Name", Name }
            };

            Hashtable table = new Hashtable {
                { "Version", Version },
                { "Enabled", Enabled },
                { "Expires", Expires },
                { "NotBefore", NotBefore },
                { "ContentType", ContentType },
                { "Tags", Tags },
                { "SecretValue", SecretData }
            };

            if (Tags != null)
            {
                table.Add("Tags", String.Join(";", Tags));
            }

            return(SQLiteDB.UpdateRow(TableName, table, filter, Exact));
        }
示例#8
0
        /// <summary>
        /// Process Record
        /// </summary>
        protected override void ProcessRecord()
        {
            Data.KeyVault KeyVault = KeyVaultHelper.GetItem(null, VaultName, true);

            Data.Computer[] searchcomputer = GetPSAdminComputer.Call(null, VaultName, ComputerName, null, true);
            if (searchcomputer.Length > 0)
            {
                WriteError(
                    (new PSAdminException(PSAdminExceptionType.ItemExists, ComputerName, "ComputerName")).GetErrorRecord()
                    );
                return;
            }

            Hashtable item = new Hashtable {
                { "Id", Guid.NewGuid().ToString().Replace("-", "") },
                { "VaultName", VaultName },
                { "ComputerName", ComputerName },
                { "Description", Description },
                { "Created", DateTime.UtcNow },
                { "Updated", DateTime.UtcNow },
                { "LastOnline", LastOnline },
                { "AssetNumber", AssetNumber },
                { "SerialNumber", SerialNumber },
                { "DeviceSKU", DeviceSKU },
                { "OSVersion", OSVersion },
                { "Location", Location },
                { "Building", Building },
                { "Room", Room },
                { "Rack", Rack },
                { "Slot", Slot },
                { "VMHost", VMHost },
                { "BuildDefinition", BuildDefinition },
                { "BuildState", BuildState },
                { "BuildDesiredVersion", BuildDesiredVersion },
                { "BuildActualVersion", BuildActualVersion },
                { "Domain", Domain },
                { "Forest", Forest },
                { "PublicFQDN", PublicFQDN },
                { "LoadBalancer", LoadBalancer },
                { "PublicIP", PublicIP },
                { "LocalIP", LocalIP },
                { "MACAddress", MACAddress },
                { "Notes", Notes }
            };

            if (Tags != null)
            {
                item.Add("Tags", String.Join(";", Tags));
            }

            bool issuccessful = Call(item);

            if (!issuccessful)
            {
                WriteError(
                    (new PSAdminException(PSAdminExceptionType.RowCreate)).GetErrorRecord()
                    );
            }
            if (Passthru)
            {
                Data.Computer[] results = GetPSAdminComputer.Call(null, VaultName, ComputerName, null, true);

                // Unroll the object
                foreach (Data.Computer result in results)
                {
                    WriteObject(result);
                }
            }
        }