public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("AllowMultiSigning=" + AllowMultiSigning.ToString());
sb.AppendLine("CertificateFile=" + CertificateFile.ToString());
sb.AppendLine("DisplaySignatureInDocument=" + DisplaySignatureInDocument.ToString());
sb.AppendLine("Enabled=" + Enabled.ToString());
sb.AppendLine("LeftX=" + LeftX.ToString());
sb.AppendLine("LeftY=" + LeftY.ToString());
sb.AppendLine("RightX=" + RightX.ToString());
sb.AppendLine("RightY=" + RightY.ToString());
sb.AppendLine("SignContact=" + SignContact.ToString());
sb.AppendLine("SignLocation=" + SignLocation.ToString());
sb.AppendLine("SignReason=" + SignReason.ToString());
sb.AppendLine("SignatureCustomPage=" + SignatureCustomPage.ToString());
sb.AppendLine("SignaturePage=" + SignaturePage.ToString());
sb.AppendLine("SignaturePassword="******"TimeServerIsSecured=" + TimeServerIsSecured.ToString());
sb.AppendLine("TimeServerLoginName=" + TimeServerLoginName.ToString());
sb.AppendLine("TimeServerPassword="******"TimeServerUrl=" + TimeServerUrl.ToString());
return(sb.ToString());
}
private void AddCertificates(CertificateList uploadedCertificates)
{
if (_azureService.Components.CloudConfig.Role != null)
{
foreach (ServiceConfigurationSchema.Certificate certElement in _azureService.Components.CloudConfig.Role.SelectMany(r => r.Certificates).Distinct())
{
if (uploadedCertificates == null || (uploadedCertificates.Count <Certificate>(c => c.Thumbprint.Equals(
certElement.thumbprint, StringComparison.OrdinalIgnoreCase)) < 1))
{
X509Certificate2 cert = General.GetCertificateFromStore(certElement.thumbprint);
CertificateFile certFile = null;
try
{
certFile = new CertificateFile
{
Data = Convert.ToBase64String(cert.Export(X509ContentType.Pfx, string.Empty)),
Password = string.Empty,
CertificateFormat = "pfx"
};
}
catch (CryptographicException exception)
{
throw new ArgumentException(string.Format(Resources.CertificatePrivateKeyAccessError, certElement.name), exception);
}
RetryCall(subscription => Channel.AddCertificates(subscription, _hostedServiceName, certFile));
WaitForCertificateToBeAdded(certElement);
}
}
}
}
public void Do_not_add_duplicate_files()
{
var certificate = new Certificate();
var file = new CertificateFile();
certificate.NewFile(file);
certificate.NewFile(file);
Assert.That(certificate.CertificateFiles.Count, Is.EqualTo(1));
}
public IAsyncResult BeginAddCertificates(string subscriptionId, string serviceName, CertificateFile input, AsyncCallback callback, object state)
{
SimpleServiceManagementAsyncResult result = new SimpleServiceManagementAsyncResult();
result.Values["subscriptionId"] = subscriptionId;
result.Values["serviceName"] = serviceName;
result.Values["input"] = input;
result.Values["callback"] = callback;
result.Values["state"] = state;
return result;
}
public void Create_HashesStream()
{
using (var stream = new MemoryStream(Encoding.UTF8.GetBytes("abc")))
{
var file = CertificateFile.Create(stream);
Assert.Equal("a9993e364706816aba3e25717850c26c9cd0d89d", file.Sha1Thumbprint);
Assert.Equal("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad", file.Sha256Thumbprint);
}
}
public void Create_HashesEmptyStream()
{
using (var stream = new MemoryStream())
{
var file = CertificateFile.Create(stream);
Assert.Equal("da39a3ee5e6b4b0d3255bfef95601890afd80709", file.Sha1Thumbprint);
Assert.Equal("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", file.Sha256Thumbprint);
}
}
public void Create_CreatesReadOnlyCopyOfStream()
{
using (var stream = new MemoryStream())
{
var file = CertificateFile.Create(stream);
Assert.False(file.Stream.CanWrite);
Assert.Equal(0, file.Stream.Position);
Assert.NotSame(stream, file.Stream);
}
}
protected override void PerformOperation(IServiceManagement channel)
{
var input = new CertificateFile()
{
CertificateFormat = Cert_format,
Password = Cert_Password,
};
input.Data = Convert.ToBase64String(File.ReadAllBytes(Cert_file));
Console.WriteLine("Adding Certificate");
channel.AddCertificates(SubscriptionId, HostedServiceName, input);
}
internal void ExecuteCommand()
{
Password = Password ?? string.Empty;
var certData = GetCertificateData();
var certificateFile = new CertificateFile
{
Data = Convert.ToBase64String(certData),
Password = Password,
CertificateFormat = "pfx"
};
ExecuteClientActionInOCS(null, CommandRuntime.ToString(), s => this.Channel.AddCertificates(s, this.ServiceName, certificateFile));
}
/// <summary>
/// Connect to an Azure subscription and obtain a certificate.
/// </summary>
/// <returns>The asynchronous operation identifier.</returns>
protected override string AzureExecute()
{
CertificateFile file = this.CreateFileFromCertificate();
try
{
this.RetryCall(s => this.Channel.AddCertificates(s, this.ServiceName.Get(this.ActivityContext), file));
return(BaseAzureAsynchronousActivity.RetrieveOperationId());
}
catch (EndpointNotFoundException ex)
{
this.LogBuildMessage(ex.Message);
return(null);
}
}
public static CertificateFile Create(X509Certificate2 certificate, bool dropPrivateKey)
{
if (dropPrivateKey)
{
certificate = DropPrivateKey(certificate);
}
var password = CertUtils.RandomBase64PasswordString();
var certificateData = GetCertificateData(certificate, password);
var certificateFile = new CertificateFile
{
Data = Convert.ToBase64String(certificateData),
Password = password,
CertificateFormat = "pfx"
};
return certificateFile;
}
public static CertificateFile Create(X509Certificate2 certificate, bool dropPrivateKey)
{
if (dropPrivateKey)
{
certificate = DropPrivateKey(certificate);
}
var password = CertUtils.RandomBase64PasswordString();
var certificateData = GetCertificateData(certificate, password);
var certificateFile = new CertificateFile
{
Data = Convert.ToBase64String(certificateData),
Password = password,
CertificateFormat = "pfx"
};
return(certificateFile);
}
private void AddFile(string certificatesPath, string certificateFilename, IList <CertificateFile> list)
{
var originFileName = Path.Combine(certificatesPath, certificateFilename);
if (File.Exists(originFileName))
{
var tempFile = Path.GetTempFileName();
File.Copy(originFileName, tempFile, true);
var certificateFile = new CertificateFile(tempFile, certificateFilename, originFileName);
if (String.IsNullOrWhiteSpace(certificateFile.Extension) ||
(!certificateFile.Extension.Equals(".tif", StringComparison.OrdinalIgnoreCase) && !certificateFile.Extension.Equals(".jpg", StringComparison.OrdinalIgnoreCase)))
{
certificateFile.Extension = ".tif";
}
list.Add(certificateFile);
}
}
public Certificate Certificate(Catalog catalog, string certificateSource = null)
{
var serial = DateTime.Today.ToShortDateString();
var certificate = new Certificate {
SerialNumber = serial,
Product = catalog
};
var certificateFile = new CertificateFile {
CertificateSourceId = certificateSource,
Extension = ".tif"
};
certificate.Files.Add(certificateFile);
session.Save(certificateFile);
session.Save(certificate);
return(certificate);
}
private void verifyCertificate(string path)
{
var disallowed = false;
try
{
var certificate = new CertificateFile(new X509Certificate2(path));
disallowed = certificate.IsDisallowed;
certificate.Dispose();
}
catch (CryptographicException ex)
{
error($"Certificate error: {ex.Message}, path={path}");
}
if (disallowed)
{
if (clean)
{
try
{
File.Delete(path);
log($"Verified {path}: Disallowed and deleted.");
}
catch (Exception ex)
{
error($"Error deleting file {path}: {ex.Message}");
}
}
else
{
log($"Verified {path}: Disallowed.");
}
}
else
{
log($"Verified {path}: NOT disallowed.");
}
}
internal void AddCertificateProcess()
{
Action <string> action = null;
this.ValidateParameters();
byte[] certificateData = this.GetCertificateData();
CertificateFile certificateFile = new CertificateFile();
certificateFile.Data = Convert.ToBase64String(certificateData);
certificateFile.Password = this.Password;
certificateFile.CertificateFormat = "pfx";
CertificateFile certificateFile1 = certificateFile;
using (OperationContextScope operationContextScope = new OperationContextScope((IContextChannel)base.Channel))
{
try
{
AddAzureCertificateCommand addAzureCertificateCommand = this;
if (action == null)
{
action = (string s) => base.Channel.AddCertificates(s, this.ServiceName, certificateFile1);
}
((CmdletBase <IServiceManagement>)addAzureCertificateCommand).RetryCall(action);
Operation operation = base.WaitForOperation(base.CommandRuntime.ToString());
ManagementOperationContext managementOperationContext = new ManagementOperationContext();
managementOperationContext.set_OperationDescription(base.CommandRuntime.ToString());
managementOperationContext.set_OperationId(operation.OperationTrackingId);
managementOperationContext.set_OperationStatus(operation.Status);
ManagementOperationContext managementOperationContext1 = managementOperationContext;
base.WriteObject(managementOperationContext1, true);
}
catch (CommunicationException communicationException1)
{
CommunicationException communicationException = communicationException1;
this.WriteErrorDetails(communicationException);
}
}
}
private void GetCertificateFile()
{
this.CertificateInfoGroup.Visibility = Visibility.Collapsed;
var password = this.CertPasswordText.Password;
var certFile = this.OpenFileDialog();
if (certFile != null)
{
try
{
var certificate = string.IsNullOrEmpty(password) ? new X509Certificate2(certFile.Content) : new X509Certificate2(certFile.Content, password);
this.PrintCertificateInfo(certificate);
_lastSelectedCertificate = certificate;
_lastSelectedFile = certFile;
}
catch (CryptographicException e)
{
MessageBox.Show(e.Message, $"Can't open: {certFile.FileName}");
}
}
}
private void AddCertificates(CertificateList uploadedCertificates, PublishContext context)
{
string name = context.ServiceName;
AzureService cloudServiceProject = new AzureService(context.RootPath, null);
if (cloudServiceProject.Components.CloudConfig.Role != null)
{
foreach (ConfigCertificate certElement in cloudServiceProject.Components.CloudConfig.Role.
SelectMany(r => r.Certificates ?? new ConfigCertificate[0]).Distinct())
{
if (uploadedCertificates == null || (uploadedCertificates.Count(c => c.Thumbprint.Equals(
certElement.thumbprint, StringComparison.OrdinalIgnoreCase)) < 1))
{
X509Certificate2 cert = General.GetCertificateFromStore(certElement.thumbprint);
CertificateFile certFile = null;
try
{
certFile = new CertificateFile
{
Data = Convert.ToBase64String(cert.Export(X509ContentType.Pfx, string.Empty)),
Password = string.Empty,
CertificateFormat = "pfx"
};
}
catch (CryptographicException exception)
{
throw new ArgumentException(string.Format(
Resources.CertificatePrivateKeyAccessError,
certElement.name), exception);
}
CallSync(() => ServiceManagementChannel.AddCertificates(subscriptionId, name, certFile));
}
}
}
}
private void AddCertificates(CertificateList uploadedCertificates, PublishContext context)
{
string name = context.ServiceName;
CloudServiceProject cloudServiceProject = new CloudServiceProject(context.RootPath, null);
if (cloudServiceProject.Components.CloudConfig.Role != null)
{
foreach (ConfigCertificate certElement in cloudServiceProject.Components.CloudConfig.Role.
SelectMany(r => r.Certificates ?? new ConfigCertificate[0]).Distinct())
{
if (uploadedCertificates == null || (uploadedCertificates.Count(c => c.Thumbprint.Equals(
certElement.thumbprint, StringComparison.OrdinalIgnoreCase)) < 1))
{
X509Certificate2 cert = General.GetCertificateFromStore(certElement.thumbprint);
CertificateFile certFile = null;
try
{
certFile = new CertificateFile
{
Data = Convert.ToBase64String(cert.Export(X509ContentType.Pfx, string.Empty)),
Password = string.Empty,
CertificateFormat = "pfx"
};
}
catch (CryptographicException exception)
{
throw new ArgumentException(string.Format(
Resources.CertificatePrivateKeyAccessError,
certElement.name), exception);
}
CallSync(() => ServiceManagementChannel.AddCertificates(subscriptionId, name, certFile));
}
}
}
}
public override bool Equals(object o)
{
if (!(o is Signature))
{
return(false);
}
Signature v = o as Signature;
if (!AllowMultiSigning.Equals(v.AllowMultiSigning))
{
return(false);
}
if (!CertificateFile.Equals(v.CertificateFile))
{
return(false);
}
if (!DisplaySignatureInDocument.Equals(v.DisplaySignatureInDocument))
{
return(false);
}
if (!Enabled.Equals(v.Enabled))
{
return(false);
}
if (!LeftX.Equals(v.LeftX))
{
return(false);
}
if (!LeftY.Equals(v.LeftY))
{
return(false);
}
if (!RightX.Equals(v.RightX))
{
return(false);
}
if (!RightY.Equals(v.RightY))
{
return(false);
}
if (!SignContact.Equals(v.SignContact))
{
return(false);
}
if (!SignLocation.Equals(v.SignLocation))
{
return(false);
}
if (!SignReason.Equals(v.SignReason))
{
return(false);
}
if (!SignatureCustomPage.Equals(v.SignatureCustomPage))
{
return(false);
}
if (!SignaturePage.Equals(v.SignaturePage))
{
return(false);
}
if (!SignaturePassword.Equals(v.SignaturePassword))
{
return(false);
}
if (!TimeServerAccountId.Equals(v.TimeServerAccountId))
{
return(false);
}
return(true);
}
public void Create_WhenStreamIsNull_Throws()
{
var exception = Assert.Throws <ArgumentNullException>(() => CertificateFile.Create(stream: null));
Assert.Equal("stream", exception.ParamName);
}
internal void ExecuteCommand()
{
Password = Password ?? string.Empty;
var certData = GetCertificateData();
var certificateFile = new CertificateFile
{
Data = Convert.ToBase64String(certData),
Password = Password,
CertificateFormat = Resources.Pfx_CertificateFormat
};
ExecuteClientActionInOCS(null, CommandRuntime.ToString(), s => this.Channel.AddCertificates(s, this.ServiceName, certificateFile));
}
public static void AddCertificates(this IServiceManagement proxy, string subscriptionId, string serviceName, CertificateFile input)
{
proxy.EndAddCertificates(proxy.BeginAddCertificates(subscriptionId, serviceName, input, null, null));
}
private CertificateFile Find(CertificateFile file)
{
return
(CertificateFile.Queryable.FirstOrDefault(
e => e.CertificateSource.Id == file.CertificateSource.Id && e.ExternalFileId == file.ExternalFileId));
}
public static void AddCertificates(this IServiceManagement proxy, string subscriptionId, string serviceName, CertificateFile input)
{
proxy.EndAddCertificates(proxy.BeginAddCertificates(subscriptionId, serviceName, input, null, null));
}
private void AddCertificates(CertificateList uploadedCertificates)
{
if (_azureService.Components.CloudConfig.Role != null)
{
foreach (ServiceConfigurationSchema.Certificate certElement in _azureService.Components.CloudConfig.Role.SelectMany(r => r.Certificates).Distinct())
{
if (uploadedCertificates == null || (uploadedCertificates.Count<Certificate>(c => c.Thumbprint.Equals(
certElement.thumbprint, StringComparison.OrdinalIgnoreCase)) < 1))
{
X509Certificate2 cert = General.GetCertificateFromStore(certElement.thumbprint);
CertificateFile certFile = null;
try
{
certFile = new CertificateFile
{
Data = Convert.ToBase64String(cert.Export(X509ContentType.Pfx, string.Empty)),
Password = string.Empty,
CertificateFormat = "pfx"
};
}
catch (CryptographicException exception)
{
throw new ArgumentException(string.Format(Resources.CertificatePrivateKeyAccessError, certElement.name), exception);
}
RetryCall(subscription => Channel.AddCertificates(subscription, _hostedServiceName, certFile));
WaitForCertificateToBeAdded(certElement);
}
}
}
}
