public ClientCertificatesForUserViewModel(IClientCertificatesRepository clientCertificatesRepository, IUserManagementRepository userManagementRepository, string username)
{
this.clientCertificatesRepository = clientCertificatesRepository;
this.userManagementRepository = userManagementRepository;
var allnames =
userManagementRepository.GetUsers()
.Select(x => new SelectListItem
{
Text = x
}).ToList();
allnames.Insert(0, new SelectListItem {
Text = "-Choose-", Value = ""
});
this.AllUserNames = allnames;
this.UserName = username;
NewCertificate = new ClientCertificate {
UserName = username
};
if (!IsNew)
{
var certs =
this.clientCertificatesRepository
.GetClientCertificatesForUser(this.UserName)
.ToArray();
this.Certificates = certs;
}
else
{
this.Certificates = new ClientCertificate[0];
}
}
private ManagedCluster GetClusterWithAddedClientCert()
{
ManagedCluster currentCluster = this.SFRPClient.ManagedClusters.Get(this.ResourceGroupName, this.Name);
if (currentCluster.Clients == null)
{
currentCluster.Clients = new List <ClientCertificate>();
}
var newCert = new ClientCertificate(isAdmin: this.Admin.IsPresent);
switch (ParameterSetName)
{
case ClientCertByTpByName:
case ClientCertByTpByObj:
newCert.Thumbprint = this.Thumbprint;
break;
case ClientCertByCnByName:
case ClientCertByCnByObj:
newCert.CommonName = this.CommonName;
newCert.IssuerThumbprint = this.IssuerThumbprint != null?string.Join(",", this.IssuerThumbprint) : null;
break;
default:
throw new ArgumentException("Invalid parameter set", ParameterSetName);
}
currentCluster.Clients.Add(newCert);
return(currentCluster);
}
protected override ConnectionSettings Authenticate(ConnectionSettings s) => s // <1> Set the client certificate on `ConnectionSettings`
.ClientCertificate(
ClientCertificate.LoadWithPrivateKey(
this.Node.FileSystem.ClientCertificate, // <2> The path to the `.cer` file
this.Node.FileSystem.ClientPrivateKey, // <3> The path to the `.key` file
"") // <4> The password for the private key
);
public ActionResult Add(ClientCertificate newCertificate, ClientCertificateInputModel file)
{
if (String.IsNullOrEmpty(newCertificate.Thumbprint) && file != null && file.Cert != null)
{
newCertificate.Thumbprint = file.Cert.Thumbprint;
if (newCertificate.Thumbprint != null)
{
ModelState["newCertificate.Thumbprint"].Errors.Clear();
ModelState["newCertificate.Thumbprint"].Value = new ValueProviderResult(newCertificate.Thumbprint, newCertificate.Thumbprint, ModelState["newCertificate.Thumbprint"].Value.Culture);
}
}
if (ModelState.IsValid)
{
try
{
this.clientCertificatesRepository.Add(newCertificate);
TempData["Message"] = Resources.ClientCertificateController.CertificateAdded;
return(RedirectToAction("Configure", new { id = newCertificate.UserName }));
}
catch (ValidationException ex)
{
ModelState.AddModelError("", ex.Message);
}
catch
{
ModelState.AddModelError("", Resources.ClientCertificateController.ErrorAddingClientCertificate);
}
}
var vm = new ClientCertificatesForUserViewModel(this.clientCertificatesRepository, this.userManagementRepository, newCertificate.UserName);
vm.NewCertificate = newCertificate;
return(View("Configure", vm));
}
public static ClientCertificateEntity ToEntity(this ClientCertificate model, string partitionKey)
{
return(new ClientCertificateEntity(model.Thumbprint, model.UserName, model.Description)
{
PartitionKey = partitionKey
});
}
private Client(ClientCertificate certificate, string baseUrl, string callbackUrl, string payeePaymentReference, string payeeAlias)
{
_certificate = certificate;
_baseAPIUrl = baseUrl;
_callbackUrl = callbackUrl;
_payeeAlias = payeeAlias;
_payeePaymentReference = payeePaymentReference;
}
internal void MakeReadOnly()
{
_isReadOnly = true;
ClientCertificate.MakeReadOnly();
IssuedTokenAuthentication.MakeReadOnly();
SecureConversationAuthentication.MakeReadOnly();
ServiceCertificate.MakeReadOnly();
UserNameAuthentication.MakeReadOnly();
WindowsAuthentication.MakeReadOnly();
}
public static ClientCertificate ToDomainModel(this ClientCertificateEntity entity)
{
var cc = new ClientCertificate
{
UserName = entity.UserName,
Thumbprint = entity.RowKey,
Description = entity.Description
};
return(cc);
}
public ClientCertificateTests()
{
_fakeCertificateBytes = new byte[20];
_request = new Mock <HttpRequestBase>(MockBehavior.Strict);
var httpWorkerRequest = new Mock <HttpWorkerRequest>();
httpWorkerRequest.Setup(x => x.GetRawUrl()).Returns("/");
httpWorkerRequest.Setup(x => x.GetClientCertificate()).Returns(_fakeCertificateBytes);
HttpContext context = new HttpContext(httpWorkerRequest.Object);
_request.Setup(x => x.ClientCertificate).Returns(context.Request.ClientCertificate);
_clientCertificate = new ClientCertificate();
}
public void Dispose()
{
Close(true);
_timer?.Dispose();
_sock?.Dispose();
_ms?.Dispose();
_iStream?.Dispose();
_oStream?.Dispose();
Stream?.Dispose();
_lastListener?.Dispose();
ClientCertificate?.Dispose();
}
public void Add(ClientCertificate certificate)
{
using (var entities = IdentityServerConfigurationContext.Get())
{
var entity = new ClientCertificates
{
UserName = certificate.UserName,
Thumbprint = certificate.Thumbprint,
Description = certificate.Description
};
entities.ClientCertificates.Add(entity);
entities.SaveChanges();
}
}
public void Dispose()
{
Close(true);
_timer?.Dispose();
_sock?.Dispose();
_ms?.Dispose();
_iStream?.Dispose();
_oStream?.Dispose();
Stream?.Dispose();
_lastListener?.Dispose();
#if !NETSTANDARD1_3
ClientCertificate?.Dispose();
#endif
}
/// <summary>
/// Returns true if this registration matches the endpoint
/// model provided.
/// </summary>
/// <param name="endpoint"></param>
/// <returns></returns>
public bool Matches(EndpointModel endpoint)
{
return(endpoint != null &&
EndpointUrl == endpoint.Url &&
AlternativeUrls.DecodeAsList().ToHashSetSafe().SetEqualsSafe(
endpoint.AlternativeUrls) &&
CredentialType == (endpoint.User?.Type ?? Models.CredentialType.None) &&
JToken.DeepEquals(Credential, endpoint.User?.Value) &&
SecurityMode == (endpoint.SecurityMode ?? Models.SecurityMode.Best) &&
SecurityPolicy == endpoint.SecurityPolicy &&
endpoint.ClientCertificate.SequenceEqualsSafe(
ClientCertificate.DecodeAsByteArray()) &&
endpoint.ServerThumbprint.SequenceEqualsSafe(
ServerThumbprint.DecodeAsByteArray()));
}
public void Delete(ClientCertificate certificate)
{
using (var entities = IdentityServerConfigurationContext.Get())
{
var record =
(from entry in entities.ClientCertificates
where entry.UserName.Equals(certificate.UserName, StringComparison.OrdinalIgnoreCase) &&
entry.Thumbprint.Equals(certificate.Thumbprint, StringComparison.OrdinalIgnoreCase)
select entry)
.Single();
entities.ClientCertificates.Remove(record);
entities.SaveChanges();
}
}
/// <summary>
/// Flag endpoint as synchronized - i.e. it matches the other.
/// </summary>
/// <param name="other"></param>
internal void MarkAsInSyncWith(EndpointRegistration other)
{
_isInSync =
other != null &&
EndpointUrl == other.EndpointUrl &&
AlternativeUrls.DecodeAsList().ToHashSetSafe().SetEqualsSafe(
other.AlternativeUrls.DecodeAsList()) &&
CredentialType == other.CredentialType &&
JToken.DeepEquals(Credential, other.Credential) &&
SecurityPolicy == other.SecurityPolicy &&
SecurityMode == other.SecurityMode &&
ClientCertificate.DecodeAsByteArray().SequenceEqualsSafe(
other.ClientCertificate.DecodeAsByteArray()) &&
ServerThumbprint.DecodeAsByteArray().SequenceEqualsSafe(
other.ServerThumbprint.DecodeAsByteArray());
}
public ActionResult Add(AddClientCertificateModel model)
{
if (!ModelState.IsValid)
{
return(View());
}
var clientCert = new ClientCertificate
{
UserName = model.UserName,
Description = model.Description
};
if (model.CertificateUpload != null && model.CertificateUpload.ContentLength > 0)
{
var bytes = new byte[model.CertificateUpload.InputStream.Length];
model.CertificateUpload.InputStream.Read(bytes, 0, bytes.Length);
clientCert.Thumbprint = new X509Certificate2(bytes).Thumbprint;
}
else
{
if (string.IsNullOrWhiteSpace(model.Thumbprint))
{
ModelState.AddModelError("", "No certificate (or thumbprint) specified");
return(View());
}
clientCert.Thumbprint = model.Thumbprint;
}
try
{
Repository.Add(clientCert);
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.InnerException.Message);
return(View("Add"));
}
return(RedirectToAction("Index"));
}
/// <summary>
/// Convert to service model
/// </summary>
/// <returns></returns>
public EndpointInfoModel ToServiceModel()
{
return(new EndpointInfoModel {
ApplicationId = ApplicationId,
Registration = new EndpointRegistrationModel {
Id = DeviceId,
SiteId = string.IsNullOrEmpty(SiteId) ?
null : SiteId,
SupervisorId = string.IsNullOrEmpty(SupervisorId) ?
null : SupervisorId,
Certificate = Certificate.DecodeAsByteArray(),
AuthenticationMethods = AuthenticationMethods?.DecodeAsList(j =>
j.ToObject <AuthenticationMethodModel>()),
SecurityLevel = SecurityLevel,
EndpointUrl = string.IsNullOrEmpty(EndpointRegistrationUrl) ?
(string.IsNullOrEmpty(EndpointUrl) ?
EndpointUrlLC : EndpointUrl) : EndpointRegistrationUrl,
Endpoint = new EndpointModel {
Url = string.IsNullOrEmpty(EndpointUrl) ?
EndpointUrlLC : EndpointUrl,
AlternativeUrls = AlternativeUrls?.DecodeAsList().ToHashSetSafe(),
User = CredentialType == null ? null :
new CredentialModel {
Value = Credential,
Type = CredentialType == Models.CredentialType.None ?
null : CredentialType
},
SecurityMode = SecurityMode == Models.SecurityMode.Best ?
null : SecurityMode,
SecurityPolicy = string.IsNullOrEmpty(SecurityPolicy) ?
null : SecurityPolicy,
ClientCertificate = ClientCertificate.DecodeAsByteArray(),
ServerThumbprint = ServerThumbprint.DecodeAsByteArray()
}
},
ActivationState = ActivationState,
NotSeenSince = NotSeenSince,
EndpointState = ActivationState == EndpointActivationState.ActivatedAndConnected ?
State : (EndpointConnectivityState?)null,
OutOfSync = Connected && !_isInSync ? true : (bool?)null
});
}
/// <inheritdoc/>
public override bool Equals(object obj)
{
var registration = obj as EndpointRegistration;
return(base.Equals(registration) &&
(Activated ?? false) == (registration.Activated ?? false) &&
EndpointUrlLC == registration.EndpointUrlLC &&
SupervisorId == registration.SupervisorId &&
JToken.DeepEquals(Credential, registration.Credential) &&
State == registration.State &&
CredentialType == registration.CredentialType &&
SecurityLevel == registration.SecurityLevel &&
SecurityPolicy == registration.SecurityPolicy &&
SecurityMode == registration.SecurityMode &&
AuthenticationMethods.DecodeAsList().SetEqualsSafe(
AuthenticationMethods.DecodeAsList(), JToken.DeepEquals) &&
ClientCertificate.DecodeAsByteArray().SequenceEqualsSafe(
registration.ClientCertificate.DecodeAsByteArray()) &&
ServerThumbprint.DecodeAsByteArray().SequenceEqualsSafe(
registration.ServerThumbprint.DecodeAsByteArray()));
}
/// <inheritdoc/>
public override int GetHashCode()
{
var hashCode = base.GetHashCode();
hashCode = hashCode * -1521134295 +
EqualityComparer <string> .Default.GetHashCode(EndpointUrlLC);
hashCode = hashCode * -1521134295 +
EqualityComparer <string> .Default.GetHashCode(ApplicationId);
hashCode = hashCode * -1521134295 +
EqualityComparer <bool> .Default.GetHashCode(Activated ?? false);
hashCode = hashCode * -1521134295 +
JToken.EqualityComparer.GetHashCode(Credential);
hashCode = hashCode * -1521134295 +
EqualityComparer <int?> .Default.GetHashCode(SecurityLevel);
hashCode = hashCode * -1521134295 +
EqualityComparer <CredentialType?> .Default.GetHashCode(CredentialType);
hashCode = hashCode * -1521134295 +
EqualityComparer <EndpointConnectivityState?> .Default.GetHashCode(State);
hashCode = hashCode * -1521134295 +
EqualityComparer <SecurityMode?> .Default.GetHashCode(SecurityMode);
hashCode = hashCode * -1521134295 +
EqualityComparer <string> .Default.GetHashCode(SecurityPolicy);
hashCode = hashCode * -1521134295 +
EqualityComparer <string> .Default.GetHashCode(
ClientCertificate.DecodeAsByteArray().ToSha1Hash());
hashCode = hashCode * -1521134295 +
EqualityComparer <string> .Default.GetHashCode(
ServerThumbprint.DecodeAsByteArray().ToSha1Hash());
return(hashCode);
}
public ActionResult CertificateGeneration(ClientCertificate c)
{
decimal percentage = Convert.ToDecimal(Session["percentage"]);
decimal roundedValue = Math.Round(percentage, 2, MidpointRounding.AwayFromZero);
List <CertificateType> certificatetype = db.CertificateTypes.ToList();
ViewBag.certificate = new SelectList(certificatetype, "Certificate_Type_Id", "Certificate_Type_Name");
if (c.Certificate_Type_Id == 1)
{
c.UserName = Session["Username"].ToString();
c.Percentage = roundedValue;
c.TotalMarks = Convert.ToInt32(Session["totalmarks"]);
c.Issue_Date = DateTime.Now;
c.MarksObtained = Convert.ToInt32(Session["MarksObtained"]);
c.CourseName = Session["Coursename"].ToString();
db.ClientCertificates.Add(c);
db.SaveChanges();
ViewBag.Message = "You Have to Pay Some Amount For This";
}
if (c.Certificate_Type_Id == 2)
{
c.UserName = Session["Username"].ToString();
c.Percentage = roundedValue;
c.TotalMarks = Convert.ToInt32(Session["totalmarks"]);
c.MarksObtained = Convert.ToInt32(Session["MarksObtained"]);
c.Issue_Date = DateTime.Now;
c.CourseName = Session["Coursename"].ToString();
db.ClientCertificates.Add(c);
db.SaveChanges();
ViewBag.successfull = true;
//return RedirectToAction("Download_PDF");
}
return(View("TestCertificate"));
}
public void Add(ClientCertificate certificate)
{
using (var entities = IdentityServerConfigurationContext.Get())
{
var record =
(from entry in entities.ClientCertificates
where entry.UserName.Equals(certificate.UserName, StringComparison.OrdinalIgnoreCase) &&
entry.Thumbprint.Equals(certificate.Thumbprint, StringComparison.OrdinalIgnoreCase)
select entry)
.SingleOrDefault();
if (record == null)
{
record = new ClientCertificates
{
UserName = certificate.UserName,
Thumbprint = certificate.Thumbprint,
};
entities.ClientCertificates.Add(record);
}
record.Description = certificate.Description;
entities.SaveChanges();
}
}
public ActionResult Remove(ClientCertificate model)
{
if (ModelState.IsValid)
{
try
{
this.clientCertificatesRepository.Delete(model);
TempData["Message"] = Resources.ClientCertificateController.CertificateRemoved;
return(RedirectToAction("Configure", new { id = model.UserName }));
}
catch (ValidationException ex)
{
ModelState.AddModelError("", ex.Message);
}
catch
{
ModelState.AddModelError("", Resources.ClientCertificateController.ErrorRemovingClientCertificate);
}
}
var vm = new ClientCertificatesForUserViewModel(this.clientCertificatesRepository, this.userManagementRepository, model.UserName);
return(View("Configure", vm));
}
private bool OnValidation(object sender, X509Certificate receivedCertificate, X509Chain chain,
SslPolicyErrors sslPolicyErrors)
{
ClientCertificate = new ClientCertificate(receivedCertificate, chain, sslPolicyErrors);
return !(UseClientCertificate && receivedCertificate == null);
}
public void Delete(ClientCertificate certificate)
{
NewContext.DeleteClientCertificate(certificate.ToEntity());
}
private bool OnValidation(object sender, X509Certificate receivedCertificate, X509Chain chain,
SslPolicyErrors sslPolicyErrors)
{
ClientCertificate = new ClientCertificate(receivedCertificate, chain, sslPolicyErrors);
return(!(UseClientCertificate && receivedCertificate == null));
}
internal byte[] EncryptSecretData(string data)
{
var cryptoProvider = ClientCertificate.GetRSAPublicKey();
return(cryptoProvider.Encrypt(Encoding.UTF8.GetBytes(data), RSAEncryptionPadding.Pkcs1));
}
internal string DecryptSecretData(byte[] data)
{
var cryptoProvider = ClientCertificate.GetRSAPrivateKey();
return(Encoding.UTF8.GetString(cryptoProvider.Decrypt(data, RSAEncryptionPadding.Pkcs1)));
}
public static ClientCertificateEntity ToEntity(this ClientCertificate model)
{
return(model.ToEntity(ClientCertificatesRepository.DefaultPartitionKey));
}
public void Add(ClientCertificate certificate)
{
NewContext.AddClientCertificate(certificate.ToEntity());
}
public override ConnectionSettings Authenticate(ConnectionSettings s) => s
//.ClientCertificate(this.Node.FileSystem.ClientCertificate);
.ClientCertificate(
ClientCertificate.LoadWithPrivateKey(this.Node.FileSystem.ClientCertificate, this.Node.FileSystem.ClientPrivateKey, "")
);
