public override IISSitesOptions Default(IOptionsService optionsService)
{
var ret = new IISSitesOptions();
var args = optionsService.GetArguments <IISSiteArguments>();
var sites = _helper.GetSites(false, false);
var rawSiteIds = optionsService.TryGetRequiredOption(nameof(args.SiteId), args.SiteId);
sites = ProcessSiteIds(ret, sites, rawSiteIds);
if (sites == null)
{
return(null);
}
ret.ExcludeBindings = args.ExcludeBindings.ParseCsv();
if (ret.ExcludeBindings != null)
{
ret.ExcludeBindings = ret.ExcludeBindings.Select(x => x.ConvertPunycode()).ToList();
}
var commonName = args.CommonName;
if (!string.IsNullOrWhiteSpace(commonName))
{
commonName = commonName.ToLower().Trim().ConvertPunycode();
if (sites.Any(s => s.Hosts.Contains(commonName)) &&
(ret.ExcludeBindings == null || !ret.ExcludeBindings.Contains(commonName)))
{
ret.CommonName = commonName;
}
else
{
_log.Error("Common name {commonName} not found or excluded", commonName);
return(null);
}
}
return(ret);
}
public override IISWebOptions Aquire(Target target, IOptionsService optionsService, IInputService inputService, RunLevel runLevel)
{
var args = optionsService.GetArguments <IISWebArguments>();
var ret = new IISWebOptions(args);
var ask = true;
if (target.IIS)
{
if (runLevel.HasFlag(RunLevel.Advanced))
{
ask = inputService.PromptYesNo("Use different site for installation?");
}
else
{
ask = false;
}
}
if (ask)
{
var chosen = inputService.ChooseFromList("Choose site to create new bindings",
_iisClient.WebSites,
x => new Choice <long>(x.Id)
{
Description = x.Name,
Command = x.Id.ToString()
},
false);
ret.SiteId = chosen;
}
return(ret);
}
public override IISBindingOptions Default(IOptionsService optionsService)
{
var ret = new IISBindingOptions();
var args = optionsService.GetArguments <IISBindingArguments>();
var hostName = optionsService.TryGetRequiredOption(nameof(args.Host), args.Host).ToLower();
var rawSiteId = args.SiteId;
var filterSet = _helper.GetBindings(false, false);
if (!string.IsNullOrEmpty(rawSiteId))
{
if (long.TryParse(rawSiteId, out long siteId))
{
filterSet = filterSet.Where(x => x.SiteId == siteId).ToList();
}
else
{
_log.Error("Invalid SiteId {siteId}", rawSiteId);
return(null);
}
}
var chosenTarget = filterSet.Where(x => x.HostUnicode == hostName || x.HostPunycode == hostName).FirstOrDefault();
if (chosenTarget != null)
{
ret.SiteId = chosenTarget.SiteId;
ret.Host = chosenTarget.HostUnicode;
ret.FriendlyNameSuggestion = chosenTarget.HostUnicode;
return(ret);
}
else
{
return(null);
}
}
public override SelfHostingOptions Default(Target target, IOptionsService optionsService)
{
var args = optionsService.GetArguments <SelfHostingArguments>();
return(new SelfHostingOptions()
{
Port = args.ValidationPort
});
}
public override DreamhostOptions Aquire(Target target, IOptionsService options, IInputService input, RunLevel runLevel)
{
var arguments = options.GetArguments <DreamhostArguments>();
return(new DreamhostOptions()
{
ApiKey = options.TryGetOption(arguments.ApiKey, input, "ApiKey", true),
});
}
public override EcOptions Default(IOptionsService optionsService)
{
var args = optionsService.GetArguments <CsrArguments>();
return(new EcOptions()
{
OcspMustStaple = args.OcspMustStaple
});
}
public override DreamhostOptions Default(Target target, IOptionsService options)
{
var az = options.GetArguments <DreamhostArguments>();
return(new DreamhostOptions()
{
ApiKey = options.TryGetRequiredOption(nameof(az.ApiKey), az.ApiKey),
});
}
public override CertificateStorePluginOptions Default(IOptionsService optionsService)
{
var args = optionsService.GetArguments <CertificateStoreArguments>();
return(new CertificateStorePluginOptions {
StoreName = args.CertificateStore,
KeepExisting = args.KeepExisting
});
}
public override AzureOptions Aquire(Target target, IOptionsService options, IInputService input, RunLevel runLevel)
{
var az = options.GetArguments <AzureArguments>();
return(new AzureOptions()
{
TenantId = options.TryGetOption(az.AzureTenantId, input, "Tenant Id"),
ClientId = options.TryGetOption(az.AzureClientId, input, "Client Id"),
Secret = options.TryGetOption(az.AzureSecret, input, "Secret", true),
SubscriptionId = options.TryGetOption(az.AzureSubscriptionId, input, "DNS Subscription ID"),
ResourceGroupName = options.TryGetOption(az.AzureResourceGroupName, input, "DNS Resoure Group Name")
});
}
public override AzureOptions Default(Target target, IOptionsService options)
{
var az = options.GetArguments <AzureArguments>();
return(new AzureOptions()
{
TenantId = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureTenantId),
ClientId = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureClientId),
Secret = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureSecret),
SubscriptionId = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureSubscriptionId),
ResourceGroupName = options.TryGetRequiredOption(nameof(az.AzureTenantId), az.AzureResourceGroupName)
});
}
public override ScriptOptions Default(Target target, IOptionsService optionsService)
{
var args = optionsService.GetArguments <ScriptArguments>();
var ret = new ScriptOptions
{
Script = optionsService.TryGetRequiredOption(nameof(args.Script), args.Script)
};
if (!ret.Script.ValidFile(_log))
{
throw new ArgumentException(nameof(args.Script));
}
ret.ScriptParameters = args.ScriptParameters;
return(ret);
}
public override ScriptOptions Aquire(Target target, IOptionsService options, IInputService input, RunLevel runLevel)
{
var args = options.GetArguments <ScriptArguments>();
var ret = new ScriptOptions();
do
{
ret.CreateScript = options.TryGetOption(args.DnsCreateScript, input, "Path to script that creates DNS records. Parameters passed are the hostname, record name and token");
}while (!ret.CreateScript.ValidFile(_log));
do
{
ret.DeleteScript = options.TryGetOption(args.DnsDeleteScript, input, "Path to script that deletes DNS records. Parameters passed are the hostname and record name");
}while (!ret.DeleteScript.ValidFile(_log));
return(ret);
}
public override CentralSslOptions Aquire(IOptionsService optionsService, IInputService inputService, RunLevel runLevel)
{
var args = optionsService.GetArguments <CentralSslArguments>();
var path = args.CentralSslStore;
while (!path.ValidPath(_log))
{
path = inputService.RequestString("Path to Central SSL store");
}
return(new CentralSslOptions
{
Path = path,
KeepExisting = args.KeepExisting,
PfxPassword = inputService.ReadPassword("Password to use for the PFX files")
});
}
public override IISFtpOptions Default(Target renewal, IOptionsService optionsService)
{
var args = optionsService.GetArguments <IISFtpArguments>();
var ret = new IISFtpOptions();
var siteId = args.FtpSiteId;
if (siteId == null)
{
throw new Exception($"Missing parameter --{nameof(args.FtpSiteId).ToLower()}");
}
// Throws exception when site is not found
var site = _iisClient.GetFtpSite(siteId.Value);
ret.SiteId = site.Id;
return(ret);
}
public override IISSiteOptions Default(IOptionsService optionsService)
{
var ret = new IISSiteOptions();
var args = optionsService.GetArguments <IISSiteArguments>();
var rawSiteId = optionsService.TryGetRequiredOption(nameof(args.SiteId), args.SiteId);
if (long.TryParse(rawSiteId, out long siteId))
{
var site = _helper.GetSites(false, false).FirstOrDefault(binding => binding.Id == siteId);
if (site != null)
{
ret.SiteId = site.Id;
ret.ExcludeBindings = args.ExcludeBindings.ParseCsv();
if (ret.ExcludeBindings != null)
{
ret.ExcludeBindings = ret.ExcludeBindings.Select(x => x.ConvertPunycode()).ToList();
}
ret.FriendlyNameSuggestion = $"Site-{ret.SiteId}";
var commonName = args.CommonName;
if (!string.IsNullOrWhiteSpace(commonName))
{
commonName = commonName.ToLower().Trim().ConvertPunycode();
if (site.Hosts.Contains(commonName) &&
(ret.ExcludeBindings == null || !ret.ExcludeBindings.Contains(commonName)))
{
ret.CommonName = commonName;
}
else
{
_log.Error("Common name {commonName} not found or excluded", commonName);
return(null);
}
}
return(ret);
}
else
{
_log.Error("Unable to find SiteId {siteId}", siteId);
}
}
else
{
_log.Error("Invalid SiteId {siteId}", args.SiteId);
}
return(null);
}
public override IISWebOptions Default(Target target, IOptionsService optionsService)
{
var args = optionsService.GetArguments <IISWebArguments>();
var ret = new IISWebOptions(args);
if (args.InstallationSiteId != null)
{
// Throws exception when not found
var site = _iisClient.GetWebSite(args.InstallationSiteId.Value);
ret.SiteId = site.Id;
}
else if (!target.IIS)
{
throw new Exception($"Missing parameter --{nameof(args.InstallationSiteId).ToLower()}");
}
return(ret);
}
public override FileSystemOptions Default(Target target, IOptionsService optionsService)
{
var args = optionsService.GetArguments <FileSystemArguments>();
var ret = new FileSystemOptions(BaseDefault(target, optionsService));
if (target.IIS && _iisClient.HasWebSites)
{
if (args.ValidationSiteId != null)
{
// Throws exception when not found
var site = _iisClient.GetWebSite(args.ValidationSiteId.Value);
ret.Path = site.Path;
ret.SiteId = args.ValidationSiteId.Value;
}
}
return(ret);
}
public override ManualOptions Default(IOptionsService optionsService)
{
var args = optionsService.GetArguments <ManualArguments>();
var input = optionsService.TryGetRequiredOption(nameof(args.Host), args.Host);
var ret = Create(input);
var commonName = args.CommonName;
if (!string.IsNullOrWhiteSpace(commonName))
{
commonName = commonName.ToLower().Trim().ConvertPunycode();
ret.CommonName = commonName;
if (!ret.AlternativeNames.Contains(commonName))
{
ret.AlternativeNames.Insert(0, commonName);
}
}
return(ret);
}
public override ScriptOptions Default(Target target, IOptionsService options)
{
var args = options.GetArguments <ScriptArguments>();
var ret = new ScriptOptions
{
CreateScript = options.TryGetRequiredOption(nameof(args.DnsCreateScript), args.DnsCreateScript),
DeleteScript = options.TryGetRequiredOption(nameof(args.DnsDeleteScript), args.DnsDeleteScript)
};
if (!ret.CreateScript.ValidFile(_log))
{
throw new ArgumentException(nameof(args.DnsCreateScript));
}
if (!ret.DeleteScript.ValidFile(_log))
{
throw new ArgumentException(nameof(args.DnsDeleteScript));
}
return(ret);
}
public override CentralSslOptions Default(IOptionsService optionsService)
{
var args = optionsService.GetArguments <CentralSslArguments>();
var path = optionsService.TryGetRequiredOption(nameof(args.CentralSslStore), args.CentralSslStore);
if (path.ValidPath(_log))
{
return(new CentralSslOptions
{
Path = path,
KeepExisting = args.KeepExisting,
PfxPassword = args.PfxPassword
});
}
else
{
throw new Exception("Invalid path specified");
}
}
public override ScriptOptions Aquire(Target target, IOptionsService optionsService, IInputService inputService, RunLevel runLevel)
{
var ret = new ScriptOptions();
var args = optionsService.GetArguments <ScriptArguments>();
inputService.Show("Full instructions", "https://github.com/PKISharp/win-acme/wiki/Install-Script");
do
{
ret.Script = optionsService.TryGetOption(args.Script, inputService, "Enter the path to the script that you want to run after renewal");
}while (!ret.Script.ValidFile(_log));
inputService.Show("{0}", "Common name");
inputService.Show("{1}", ".pfx password");
inputService.Show("{2}", ".pfx path");
inputService.Show("{3}", "Store name");
inputService.Show("{4}", "Friendly name");
inputService.Show("{5}", "Certificate thumbprint");
ret.ScriptParameters = optionsService.TryGetOption(args.ScriptParameters, inputService, "Enter the parameter format string for the script, e.g. \"--hostname {0}\"");
return(ret);
}
/// <summary>
/// Get webroot automatically
/// </summary>
public HttpValidationOptions <TPlugin> BaseDefault(Target target, IOptionsService options)
{
string path = null;
var allowEmpty = AllowEmtpy(target);
var args = options.GetArguments <HttpValidationArguments>();
if (string.IsNullOrEmpty(path) && !allowEmpty)
{
path = options.TryGetRequiredOption(nameof(args.WebRoot), args.WebRoot);
}
if (!string.IsNullOrEmpty(path) && !PathIsValid(path))
{
throw new ArgumentException($"Invalid webroot {path}: {WebrootHint(false)[0]}");
}
return(new TOptions
{
Path = path,
CopyWebConfig = target.IIS || args.ManualTargetIsIIS
});
}
