public ContextProvider(RmsClientManagerContext clientContext, PerTenantRMSTrustedPublishingDomainConfiguration perTenantconfig)
{
if (clientContext == null)
{
throw new ArgumentNullException("clientContext");
}
if (perTenantconfig == null)
{
throw new ArgumentNullException("perTenantconfig");
}
if (perTenantconfig.PrivateKeys == null)
{
throw new ArgumentNullException("perTenantconfig.PrivateKeys");
}
this.clientContext = clientContext;
this.configProvider = new ConfigurationInformationProvider(perTenantconfig);
this.privateKeyProvider = new TrustedPublishingDomainPrivateKeyProvider(clientContext, perTenantconfig.PrivateKeys);
this.globalConfigurationProvider = new GlobalConfigurationCacheProvider();
this.directoryServiceProvider = new DirectoryServiceProvider(clientContext);
}
public static int GetTenantActiveCryptoMode(RmsClientManagerContext clientContext)
{
ArgumentValidator.ThrowIfNull("clientContext", clientContext);
ServerManager.InitializeIfNeeded();
if (ServerManager.instance.isHostingInstance)
{
PerTenantRMSTrustedPublishingDomainConfiguration tenantTrustedPublishingDomainConfig = ServerManager.instance.GetTenantTrustedPublishingDomainConfig(clientContext);
return(tenantTrustedPublishingDomainConfig.ActiveCryptoMode);
}
ActiveCryptoModeRpcResult[] tenantActiveCryptoMode = RpcClientWrapper.GetTenantActiveCryptoMode(clientContext);
ActiveCryptoModeResult[] array = new ActiveCryptoModeResult[tenantActiveCryptoMode.Length];
for (int i = 0; i < tenantActiveCryptoMode.Length; i++)
{
RightsManagementServerException e = null;
if (tenantActiveCryptoMode[i].ErrorResults != null && tenantActiveCryptoMode[i].ErrorResults.Count > 0)
{
e = new RightsManagementServerException(tenantActiveCryptoMode[i].GetSerializedString(), tenantActiveCryptoMode[i].IsPermanentFailure);
}
array[i] = new ActiveCryptoModeResult(tenantActiveCryptoMode[i].ActiveCryptoMode, e);
}
return(array[0].ActiveCryptoMode);
}
public override void ReadData(IConfigurationSession session)
{
RMSTrustedPublishingDomain[] array = session.Find <RMSTrustedPublishingDomain>(null, QueryScope.SubTree, null, null, 0);
if (array == null || array.Length == 0)
{
throw new RightsManagementServerException(ServerStrings.FailedToLocateTPDConfig(session.SessionSettings.CurrentOrganizationId.ToString()), false);
}
this.compressedTrustedDomainChains = new List <string>(array.Length);
this.compressedRMSTemplates = new List <string>();
this.privateKeys = new Dictionary <string, PrivateKeyInformation>(array.Length, StringComparer.OrdinalIgnoreCase);
foreach (RMSTrustedPublishingDomain rmstrustedPublishingDomain in array)
{
if (string.IsNullOrEmpty(rmstrustedPublishingDomain.SLCCertChain))
{
throw new DataValidationException(new PropertyValidationError(new LocalizedString("SLCCertChain is null from AD for tenant " + base.OrganizationId), RMSTrustedPublishingDomainSchema.SLCCertChain, null));
}
if (string.IsNullOrEmpty(rmstrustedPublishingDomain.PrivateKey))
{
throw new DataValidationException(new PropertyValidationError(new LocalizedString("PrivateKey is null from AD for tenant " + base.OrganizationId), RMSTrustedPublishingDomainSchema.PrivateKey, null));
}
if (string.IsNullOrEmpty(rmstrustedPublishingDomain.KeyId))
{
throw new DataValidationException(new PropertyValidationError(new LocalizedString("KeyId is null from AD for tenant " + base.OrganizationId), RMSTrustedPublishingDomainSchema.KeyId, null));
}
if (string.IsNullOrEmpty(rmstrustedPublishingDomain.KeyIdType))
{
throw new DataValidationException(new PropertyValidationError(new LocalizedString("KeyIdType is null from AD for tenant " + base.OrganizationId), RMSTrustedPublishingDomainSchema.KeyIdType, null));
}
if (rmstrustedPublishingDomain.IntranetLicensingUrl == null || string.IsNullOrEmpty(rmstrustedPublishingDomain.IntranetLicensingUrl.OriginalString))
{
throw new DataValidationException(new PropertyValidationError(new LocalizedString("IntranetLicensingUrl is null from AD for tenant " + base.OrganizationId), RMSTrustedPublishingDomainSchema.IntranetLicensingUrl, null));
}
if (rmstrustedPublishingDomain.ExtranetLicensingUrl == null || string.IsNullOrEmpty(rmstrustedPublishingDomain.ExtranetLicensingUrl.OriginalString))
{
throw new DataValidationException(new PropertyValidationError(new LocalizedString("ExtranetLicensingUrl is null from AD for tenant " + base.OrganizationId), RMSTrustedPublishingDomainSchema.ExtranetLicensingUrl, null));
}
if (rmstrustedPublishingDomain.Default)
{
this.intranetLicensingUrl = rmstrustedPublishingDomain.IntranetLicensingUrl;
this.estimatedSize += rmstrustedPublishingDomain.IntranetLicensingUrl.OriginalString.Length * 2;
this.extranetLicensingUrl = rmstrustedPublishingDomain.ExtranetLicensingUrl;
this.estimatedSize += rmstrustedPublishingDomain.ExtranetLicensingUrl.OriginalString.Length * 2;
if (rmstrustedPublishingDomain.IntranetCertificationUrl != null && !string.IsNullOrEmpty(rmstrustedPublishingDomain.IntranetCertificationUrl.OriginalString))
{
this.intranetCertificationUrl = rmstrustedPublishingDomain.IntranetCertificationUrl;
this.estimatedSize += rmstrustedPublishingDomain.IntranetCertificationUrl.OriginalString.Length * 2;
}
if (rmstrustedPublishingDomain.ExtranetCertificationUrl != null && !string.IsNullOrEmpty(rmstrustedPublishingDomain.ExtranetCertificationUrl.OriginalString))
{
this.extranetCertificationUrl = rmstrustedPublishingDomain.ExtranetCertificationUrl;
this.estimatedSize += rmstrustedPublishingDomain.ExtranetCertificationUrl.OriginalString.Length * 2;
}
this.compressedSLCCertChain = rmstrustedPublishingDomain.SLCCertChain;
this.estimatedSize += rmstrustedPublishingDomain.SLCCertChain.Length * 2;
this.activeCryptoMode = PerTenantRMSTrustedPublishingDomainConfiguration.CryptoModeFromCompressedSLC(this.compressedSLCCertChain);
}
if (rmstrustedPublishingDomain.RMSTemplates != null && rmstrustedPublishingDomain.RMSTemplates.Count > 0)
{
foreach (string text in rmstrustedPublishingDomain.RMSTemplates)
{
if (string.IsNullOrEmpty(text))
{
throw new DataValidationException(new PropertyValidationError(new LocalizedString("Template contains empty string for " + base.OrganizationId), RMSTrustedPublishingDomainSchema.ExtranetLicensingUrl, null));
}
this.CompressedRMSTemplates.Add(text);
this.estimatedSize += text.Length;
}
}
PrivateKeyInformation privateKeyInformation = new PrivateKeyInformation(rmstrustedPublishingDomain.KeyId, rmstrustedPublishingDomain.KeyIdType, rmstrustedPublishingDomain.KeyContainerName, rmstrustedPublishingDomain.KeyNumber, rmstrustedPublishingDomain.CSPName, rmstrustedPublishingDomain.CSPType, rmstrustedPublishingDomain.PrivateKey, rmstrustedPublishingDomain.Default);
this.estimatedSize += 8;
this.estimatedSize += rmstrustedPublishingDomain.KeyId.Length * 2;
this.estimatedSize += rmstrustedPublishingDomain.KeyIdType.Length * 2;
this.estimatedSize += rmstrustedPublishingDomain.PrivateKey.Length * 2;
if (!string.IsNullOrEmpty(rmstrustedPublishingDomain.CSPName))
{
this.estimatedSize += rmstrustedPublishingDomain.CSPName.Length * 2;
}
if (!string.IsNullOrEmpty(rmstrustedPublishingDomain.KeyContainerName))
{
this.estimatedSize += rmstrustedPublishingDomain.KeyContainerName.Length * 2;
}
this.privateKeys[privateKeyInformation.Identity] = privateKeyInformation;
this.compressedTrustedDomainChains.Add(rmstrustedPublishingDomain.SLCCertChain);
this.estimatedSize += rmstrustedPublishingDomain.SLCCertChain.Length * 2;
}
}
public static void AcquireTenantLicenses(RmsClientManagerContext clientContext, XmlNode[] machineCertificateChain, string identity, out XmlNode[] racXml, out XmlNode[] clcXml)
{
ArgumentValidator.ThrowIfNull("clientContext", clientContext);
ArgumentValidator.ThrowIfNull("machineCertificateChain", machineCertificateChain);
ArgumentValidator.ThrowIfNullOrEmpty("identity", identity);
racXml = null;
clcXml = null;
ServerManager.InitializeIfNeeded();
if (ServerManager.instance.isHostingInstance)
{
PerTenantRMSTrustedPublishingDomainConfiguration tenantTrustedPublishingDomainConfig = ServerManager.instance.GetTenantTrustedPublishingDomainConfig(clientContext);
ContextProvider contextProvider = null;
try
{
IRightsAccountCertificateGenerator rightsAccountCertificateGenerator;
IClientLicensorCertificateGenerator clientLicensorCertificateGenerator;
try
{
contextProvider = new ContextProvider(clientContext, tenantTrustedPublishingDomainConfig);
rightsAccountCertificateGenerator = GeneratorFactory.CreateRightsAccountCertificateGenerator(contextProvider);
clientLicensorCertificateGenerator = GeneratorFactory.CreateClientLicensorCertificateGenerator(contextProvider);
}
catch (ConfigurationProviderException ex)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireTenantLicenses, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed to create Generator with Exception: {0}", ServerManagerLog.GetExceptionLogString(ex, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToCreateLicenseGenerator(clientContext.OrgId.ToString(), "RacClc"), ex);
}
catch (CertificationException ex2)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireTenantLicenses, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed to create Generator with WellKnownErrorCode {0}, Exception: {1}", ex2.ErrorCode, ServerManagerLog.GetExceptionLogString(ex2, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToCreateLicenseGenerator(clientContext.OrgId.ToString(), "Rac"), ex2);
}
catch (PublishingException ex3)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireTenantLicenses, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed to create Generator with WellKnownErrorCode {0}, Exception: {1}", ex3.ErrorCode, ServerManagerLog.GetExceptionLogString(ex3, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToCreateLicenseGenerator(clientContext.OrgId.ToString(), "Clc"), ex3);
}
XrmlCertificateChain xrmlCertificateChain = new XrmlCertificateChain(DrmClientUtils.ConvertXmlNodeArrayToStringArray(machineCertificateChain));
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireTenantLicenses, ServerManagerLog.EventType.Entry, clientContext, string.Format("AcquireTenantLicenses for identity {0}", identity));
XrmlCertificateChain xrmlCertificateChain2;
XrmlCertificateChain xrmlCertificateChain3;
try
{
string text = ServerManager.ReadOrganizationRacKeysFromIRMConfig(clientContext.OrgId);
xrmlCertificateChain2 = rightsAccountCertificateGenerator.AcquireCertificate(xrmlCertificateChain, identity, text);
xrmlCertificateChain3 = clientLicensorCertificateGenerator.AcquireCertificate(xrmlCertificateChain2);
}
catch (CertificationException ex4)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireTenantLicenses, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed to AcquireTenantLicenses with WellKnownErrorCode {0}, Exception: {1}", ex4.ErrorCode, ServerManagerLog.GetExceptionLogString(ex4, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToAcquireRacAndClc(clientContext.OrgId.ToString(), identity), ex4);
}
catch (PublishingException ex5)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireTenantLicenses, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed to AcquireTenantLicenses with WellKnownErrorCode {0}, Exception: {1}", ex5.ErrorCode, ServerManagerLog.GetExceptionLogString(ex5, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToAcquireRacAndClc(clientContext.OrgId.ToString(), identity), ex5);
}
if (!RMUtil.TryConvertCertChainStringArrayToXmlNodeArray(xrmlCertificateChain2.ToStringArray(), out racXml))
{
throw new RightsManagementServerException(ServerStrings.FailedToAcquireRacAndClc(clientContext.OrgId.ToString(), identity), true);
}
if (!RMUtil.TryConvertCertChainStringArrayToXmlNodeArray(xrmlCertificateChain3.ToStringArray(), out clcXml))
{
throw new RightsManagementServerException(ServerStrings.FailedToAcquireRacAndClc(clientContext.OrgId.ToString(), identity), true);
}
return;
}
finally
{
if (contextProvider != null)
{
contextProvider.Dispose();
}
}
}
RpcClientWrapper.AcquireTenantLicenses(clientContext, machineCertificateChain, identity, out racXml, out clcXml);
}
public static UseLicenseResult[] AcquireUseLicenses(RmsClientManagerContext clientContext, XmlNode[] rightsAccountCertificate, XmlNode[] issuanceLicense, LicenseeIdentity[] licenseeIdentities)
{
ArgumentValidator.ThrowIfNull("clientContext", clientContext);
ArgumentValidator.ThrowIfNull("rightsAccountCertificate", rightsAccountCertificate);
ArgumentValidator.ThrowIfNull("issuanceLicense", issuanceLicense);
ArgumentValidator.ThrowIfNull("licenseeIdentities", licenseeIdentities);
Stopwatch watch = Stopwatch.StartNew();
ServerManager.InitializeIfNeeded();
if (ServerManager.instance.isHostingInstance)
{
PerTenantRMSTrustedPublishingDomainConfiguration tenantTrustedPublishingDomainConfig = ServerManager.instance.GetTenantTrustedPublishingDomainConfig(clientContext);
ContextProvider contextProvider = null;
try
{
IEndUserLicenseGenerator endUserLicenseGenerator;
try
{
contextProvider = new ContextProvider(clientContext, tenantTrustedPublishingDomainConfig);
endUserLicenseGenerator = GeneratorFactory.CreateEndUserLicenseGenerator(contextProvider);
}
catch (ConfigurationProviderException ex)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireUseLicense, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed in CreateEndUserLicenseGenerator with Exception: {0}", ServerManagerLog.GetExceptionLogString(ex, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToCreateLicenseGenerator(clientContext.OrgId.ToString(), "UseLicenseGenerator"), ex);
}
catch (LicensingException ex2)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireUseLicense, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed in CreateEndUserLicenseGenerator with WellKnownError {0} and Exception: {1}", ex2.ErrorCode, ServerManagerLog.GetExceptionLogString(ex2, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToCreateLicenseGenerator(clientContext.OrgId.ToString(), "UseLicenseGenerator"), ex2);
}
XrmlCertificateChain xrmlCertificateChain = new XrmlCertificateChain(DrmClientUtils.ConvertXmlNodeArrayToStringArray(issuanceLicense));
XrmlCertificateChain xrmlCertificateChain2 = new XrmlCertificateChain(DrmClientUtils.ConvertXmlNodeArrayToStringArray(rightsAccountCertificate));
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireUseLicense, ServerManagerLog.EventType.Entry, clientContext, string.Format("AcquireLicenses for {0} licensees, they are {1}", licenseeIdentities.Length, ServerManager.GetLicenseeLogString(licenseeIdentities)));
LicensingBatchResults licensingBatchResults;
try
{
licensingBatchResults = endUserLicenseGenerator.AcquireLicenses(xrmlCertificateChain2, xrmlCertificateChain, licenseeIdentities);
}
catch (LicensingException ex3)
{
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireUseLicense, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed useLicenseGenerator.AcquireLicenses with WellKnownErrorCode {0}, Exception: {1}", ex3.ErrorCode, ServerManagerLog.GetExceptionLogString(ex3, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
throw new RightsManagementServerException(ServerStrings.FailedToAcquireUseLicenses(clientContext.OrgId.ToString()), ex3);
}
int num = 0;
UseLicenseResult[] array = new UseLicenseResult[licensingBatchResults.LicensingResults.Count];
for (int i = 0; i < licensingBatchResults.LicensingResults.Count; i++)
{
StringBuilder stringBuilder = null;
if (licensingBatchResults.LicensingResults[i].EndUserLicense != null && licensingBatchResults.LicensingResults[i].Error == null)
{
stringBuilder = new StringBuilder();
stringBuilder.Append(licensingBatchResults.LicensingResults[i].EndUserLicense);
string[] array2 = licensingBatchResults.ServerLicensorCertificateChain.ToStringArray();
foreach (string value in array2)
{
stringBuilder.Append(value);
}
}
LicensingException error = licensingBatchResults.LicensingResults[i].Error;
RightsManagementServerException ex4 = (error != null) ? new RightsManagementServerException(ServerStrings.FailedToAcquireUseLicenses(clientContext.OrgId.ToString()), error) : null;
if (error != null)
{
num++;
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireUseLicense, ServerManagerLog.EventType.Error, clientContext, string.Format("Failed to AcquireLicenses for Licensee {0} with WellKnownErrorCode {1}, Exception: {2}", licenseeIdentities[i], error.ErrorCode, ServerManagerLog.GetExceptionLogString(error, ServerManagerLog.ExceptionLogOption.IncludeStack | ServerManagerLog.ExceptionLogOption.IncludeInnerException)));
}
if (stringBuilder != null && ex4 != null)
{
throw new InvalidOperationException("LicensingResult.EndUserLicense and LicensingResult.Error are both non-null");
}
if (stringBuilder == null && ex4 == null)
{
throw new InvalidOperationException("LicensingResult.EndUserLicense and LicensingResult.Error are null");
}
array[i] = new UseLicenseResult((stringBuilder != null) ? stringBuilder.ToString() : null, ex4);
}
ServerManagerLog.LogEvent(ServerManagerLog.Subcomponent.AcquireUseLicense, (num == 0) ? ServerManagerLog.EventType.Success : ServerManagerLog.EventType.Error, clientContext, string.Format("AcquireLicenses finishes with successs count {0} and failed count {1}", array.Length - num, num));
ServerManager.instance.rpcAcquireUseLicensePerformanceMonitor.Record(watch);
return(array);
}
finally
{
if (contextProvider != null)
{
contextProvider.Dispose();
}
}
}
UseLicenseRpcResult[] array4 = RpcClientWrapper.AcquireUseLicenses(clientContext, rightsAccountCertificate, issuanceLicense, licenseeIdentities);
UseLicenseResult[] array5 = new UseLicenseResult[array4.Length];
for (int k = 0; k < array4.Length; k++)
{
RightsManagementServerException e = null;
if (array4[k].ErrorResults != null && array4[k].ErrorResults.Count > 0)
{
e = new RightsManagementServerException(array4[k].GetSerializedString(), array4[k].IsPermanentFailure);
}
array5[k] = new UseLicenseResult(array4[k].EndUseLicense, e);
}
ServerManager.instance.acquireUseLicensePerformanceMonitor.Record(watch);
return(array5);
}