internal byte[] GetEncryptedBytes(ISmimeCryptographer cryptographer)
{
if (m_encryptedBytes == null)
{
m_encryptedBytes = cryptographer.GetEncryptedBytes(this.Message);
}
return(m_encryptedBytes);
}
public static DirectAgent CreateAgent(string domain, string certsBasePath, ISmimeCryptographer cryptographer)
{
MemoryX509Store privateCerts = LoadPrivateCerts(certsBasePath, false);
MemoryX509Store publicCerts = LoadPublicCerts(certsBasePath);
TrustAnchorResolver anchors = new TrustAnchorResolver(
(IX509CertificateStore)LoadIncomingAnchors(certsBasePath),
(IX509CertificateStore)LoadOutgoingAnchors(certsBasePath));
return(new DirectAgent(domain, privateCerts.CreateResolver(), publicCerts.CreateResolver(), anchors, cryptographer));
}
/// <summary>
/// Creates a DirectAgent instance, specifying private, external and trust anchor certificate stores, and
/// and defaulting to the standard trust and cryptography models.
/// </summary>
/// <param name="domain">
/// The local domain name managed by this agent.
/// </param>
/// <param name="privateCerts">
/// An <see cref="ICertificateResolver"/> instance providing private certificates
/// for senders of outgoing messages and receivers of incoming messages.
/// </param>
/// <param name="publicCerts">
/// An <see cref="ICertificateResolver"/> instance providing public certificates
/// for receivers of outgoing messages and senders of incoming messages.
/// </param>
/// <param name="anchors">
/// An <see cref="ITrustAnchorResolver"/> instance providing trust anchors.
/// </param>
/// <param name="cryptographer"><see cref="ISmimeCryptographer"/> implementation.</param>
public DirectAgent(string domain,
ICertificateResolver privateCerts,
ICertificateResolver publicCerts,
ITrustAnchorResolver anchors,
ISmimeCryptographer cryptographer)
: this(new StaticDomainResolver(domain),
privateCerts,
publicCerts,
anchors,
TrustModel.Default,
cryptographer)
{
}
/// <summary>
/// Creates a DirectAgent instance, specifying private, external and trust anchor certificate stores, and
/// trust and cryptography models.
/// </summary>
/// <param name="domainResolver">
/// An <see cref="IDomainResolver"/> instance providing array of local domain name managed by this agent.
/// </param>
/// <param name="privateCerts">
/// An <see cref="ICertificateResolver"/> instance providing private certificates
/// for senders of outgoing messages and receivers of incoming messages.
/// </param>
/// <param name="publicCerts">
/// An <see cref="ICertificateResolver"/> instance providing public certificates
/// for receivers of outgoing messages and senders of incoming messages.
/// </param>
/// <param name="anchors">
/// An <see cref="ITrustAnchorResolver"/> instance providing trust anchors.
/// </param>
/// <param name="trustModel">
/// An instance or subclass of <see cref="SMIMECryptographer"/> providing a custom trust model.
/// </param>
/// <param name="cryptographer">
/// An instance or subclass of <see cref="Health.Direct.Agent"/> providing a custom cryptography model.
/// </param>
public DirectAgent(IDomainResolver domainResolver,
ICertificateResolver privateCerts,
ICertificateResolver publicCerts,
ITrustAnchorResolver anchors,
TrustModel trustModel,
ISmimeCryptographer cryptographer)
: this(domainResolver,
privateCerts,
publicCerts,
anchors,
trustModel,
cryptographer,
CertPolicyResolvers.Default)
{
}
/// <summary>
/// Creates a DirectAgent instance, specifying private, external and trust anchor certificate stores, and
/// trust and cryptography models.
/// </summary>
/// <param name="domainResolver">
/// An <see cref="IDomainResolver"/> instance providing array of local domain name managed by this agent.
/// </param>
/// <param name="privateCerts">
/// An <see cref="ICertificateResolver"/> instance providing private certificates
/// for senders of outgoing messages and receivers of incoming messages.
/// </param>
/// <param name="publicCerts">
/// An <see cref="ICertificateResolver"/> instance providing public certificates
/// for receivers of outgoing messages and senders of incoming messages.
/// </param>
/// <param name="anchors">
/// An <see cref="ITrustAnchorResolver"/> instance providing trust anchors.
/// </param>
/// <param name="trustModel">
/// An instance or subclass of <see cref="SMIMECryptographer"/> providing a custom trust model.
/// </param>
/// <param name="cryptographer">
/// An instance or subclass of <see cref="Health.Direct.Agent"/> providing a custom cryptography model.
/// </param>
/// <param name="certPolicyResolvers">Certificate <see cref="ICertPolicyResolvers">policy container</see></param>
public DirectAgent(IDomainResolver domainResolver,
ICertificateResolver privateCerts,
ICertificateResolver publicCerts,
ITrustAnchorResolver anchors,
TrustModel trustModel,
ISmimeCryptographer cryptographer,
ICertPolicyResolvers certPolicyResolvers)
{
m_managedDomains = new AgentDomains(domainResolver);
if (privateCerts == null)
{
throw new ArgumentNullException("privateCerts");
}
if (publicCerts == null)
{
throw new ArgumentNullException("publicCerts");
}
if (anchors == null)
{
throw new ArgumentNullException("anchors");
}
if (trustModel == null)
{
throw new ArgumentNullException("trustModel");
}
if (cryptographer == null)
{
throw new ArgumentNullException("cryptographer");
}
m_privateCertResolver = privateCerts;
m_publicCertResolver = publicCerts;
m_cryptographer = cryptographer;
m_trustAnchors = anchors;
m_trustModel = trustModel;
if (!m_trustModel.CertChainValidator.HasCertificateResolver)
{
m_trustModel.CertChainValidator.IssuerResolver = m_publicCertResolver;
}
m_minTrustRequirement = TrustEnforcementStatus.Success;
m_privatePolicyResolver = certPolicyResolvers.PrivateResolver;
m_publicPolicyResolver = certPolicyResolvers.PublicResolver;
}
//
// First sign, THEN encrypt the message
//
void SignAndEncryptMessage(OutgoingMessage message)
{
ISmimeCryptographer cryptographer = ResolveOutgoingCryptographer(message.Sender);
SignedEntity signedEntity = cryptographer.Sign(message.Message, message.Sender.Certificates);
if (m_encryptionEnabled)
{
//
// Encrypt the outbound message with all known trusted certs
//
MimeEntity encryptedEntity = cryptographer.Encrypt(signedEntity.ToEntity(), message.Recipients.GetCertificates());
//
// Alter message content to contain encrypted data
//
message.Message.UpdateBody(encryptedEntity);
}
else
{
message.Message.UpdateBody(signedEntity);
}
}
/// <summary>
/// Creates a agent from settings.
/// </summary>
/// <returns>The configured agent instance.</returns>
public DirectAgent CreateAgent()
{
this.Validate();
ICertificateResolver privateCerts = this.PrivateCerts.CreateResolver();
ICertificateResolver publicCerts = this.PublicCerts.CreateResolver();
ITrustAnchorResolver trustAnchors = this.Anchors.Resolver.CreateResolver();
ICertPolicyResolvers certPolicyResolvers = GetPolicyResolvers();
TrustModel trustModel = (this.Trust != null) ? this.Trust.CreateTrustModel(certPolicyResolvers.TrustResolver) : TrustModel.Default;
ISmimeCryptographer cryptographer = this.Cryptographer.Create();
IDomainResolver domainResolver = this.CreateResolver();
DirectAgent agent = new DirectAgent(domainResolver, privateCerts, publicCerts, trustAnchors, trustModel, cryptographer, certPolicyResolvers);
agent.AllowNonWrappedIncoming = m_allowNonWrappedIncoming;
agent.WrapMessages = m_wrapOutgoing;
return(agent);
}
public void Init(TokenResolverSettings resolverSettings)
{
try
{
IPropertyManager client = resolverSettings.ClientSettings.CreatePropertyManagerClient();
Property[] properties = client.GetProperties(new [] { "TokenSettings" });
string tokenSettingsXml = properties.SingleOrDefault().Value;
var tokenSettings = tokenSettingsXml.FromXml <TokenSettings>();
m_innerSoftwareCryptographer = new SMIMECryptographer(
tokenSettings.DefaultEncryption,
tokenSettings.DefaultDigest);
tokenSettings.Error += ProxyError;
m_innerHsmCryptographer = tokenSettings.Create();
}
catch (Exception ex)
{
ProxyError.NotifyEvent(this, ex);
// Do not remove. Exceptions here can cause the Direct Project to not bind to SMTP.
}
}
public static DirectAgent CreateAgent(
IDomainResolver domain,
string certsBasePath,
ISmimeCryptographer cryptographer,
ICertPolicyResolvers certPolicyResolvers)
{
MemoryX509Store privateCerts = LoadPrivateCerts(certsBasePath, false);
MemoryX509Store publicCerts = LoadPublicCerts(certsBasePath);
TrustAnchorResolver anchors = new TrustAnchorResolver(
(IX509CertificateStore)LoadOutgoingAnchors(certsBasePath),
(IX509CertificateStore)LoadIncomingAnchors(certsBasePath));
return(new DirectAgent(
domain,
privateCerts.CreateResolver(),
publicCerts.CreateResolver(),
anchors,
TrustModel.Default,
cryptographer ?? SMIMECryptographer.Default,
certPolicyResolvers
));
}
internal void OnCryptographerWarning(ISmimeCryptographer cryptographer, string message)
{
Logger.Warn("CRYPTOGRAPHER WARNING {0}, {1}", cryptographer.GetType().Name, message);
}
internal void OnCryptographerError(ISmimeCryptographer cryptographer, Exception error)
{
Logger.Error("CRYPTOGRAPHER ERROR {0}, {1}", cryptographer.GetType().Name, error.Message);
}
public void OnResolverWarning(ISmimeCryptographer cryptographer, string message)
{
_actualWarningMessages.Add(message);
//Logger.Warn("CRYPTOGRPHER Warning {0}, {1}", resolver.GetType().Name, message);
}
public void OnResolverError(ISmimeCryptographer cryptographer, Exception error)
{
_actualErrorMessages.Add(error.Message);
//Logger.Error("CRYPTOGRPHER ERROR {0}, {1}", resolver.GetType().Name, error.Message);
}
/// <summary>
/// Used by Cryptographers to fire warning events
/// </summary>
/// <param name="handler">Event handler to fire, if any subscribers</param>
/// <param name="cryptographer">cryptographer for which this is an event handler</param>
/// <param name="message">warning message to notify</param>
public static void NotifyEvent(this Action <ISmimeCryptographer, string> handler, ISmimeCryptographer cryptographer, string message)
{
if (handler != null)
{
try
{
handler(cryptographer, message);
}
catch
{
}
}
}
/// <summary>
/// Used by Cryptographers to fire error events
/// </summary>
/// <param name="handler">Event handler to fire, if any subscribers</param>
/// <param name="cryptographer">cryptographer for which this is an event handler</param>
/// <param name="ex">exception to notify</param>
public static void NotifyEvent(this Action <ISmimeCryptographer, Exception> handler, ISmimeCryptographer cryptographer, Exception ex)
{
if (handler != null)
{
try
{
handler(cryptographer, ex);
}
catch
{
}
}
}
