internal static void ThrowOnErrorCode(int hr) { // we can return if it is not a failure right away // there is no reason to attempt to look-up codes and // messages which is somewhat expensive in the case of success if (hr >= 0) { return; } string errorMessage = GetLocalizedFailureCodeMessage((RightsManagementFailureCode)hr); if (errorMessage != null) { throw new RightsManagementException((RightsManagementFailureCode)hr, errorMessage); } else { try { // It seems that ThrowExceptionForHR is the most consistent way // to get a platform representation of the unmanaged HR code Marshal.ThrowExceptionForHR(hr); } // disabling PreSharp false positive. In this case we are actually re-throwing the same exception // wrapped in a more specific message #pragma warning disable 56500 catch (Exception e) { // rethrow the exception as an inner exception of the RmExceptionGenericMessage throw new RightsManagementException(SR.Get(SRID.RmExceptionGenericMessage), e); } #pragma warning restore 56500 } }
/// <summary> /// Returns one of the "special" property methods for a property descriptor. /// The property name will be appended to the method prefix. This method /// is used to return the MethodInfo for ShouldSerialize(property) and /// Reset(property). /// </summary> private MethodInfo GetSpecialMethod(string methodPrefix) { BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic; Type[] types; Type reflectionType; if (_property == null) { // Attached property types = DpType; flags |= BindingFlags.Static; // TypeDescriptor offers a feature called a "reflection type", which // is an indirection to another type we should reflect on. Anywyere // we rely on raw reflection we should be using GetReflectionType. reflectionType = TypeDescriptor.GetReflectionType(_dp.OwnerType); } else { // Direct property types = Type.EmptyTypes; flags |= BindingFlags.Instance; // TypeDescriptor offers a feature called a "reflection type", which // is an indirection to another type we should reflect on. Anywyere // we rely on raw reflection we should be using GetReflectionType. reflectionType = TypeDescriptor.GetReflectionType(_property.ComponentType); } string methodName = string.Concat(methodPrefix, _dp.Name); // According to spec, ShouldSerialize and Reset can be non-public. So we should // assert ReflectionPermission here, like TypeDescriptor does. But since every // assert is a security risk, we'll take the compatibility hit, and leave it out. MethodInfo methodInfo = reflectionType.GetMethod(methodName, flags, _dpBinder, types, null); if (methodInfo != null) { // We don't support non-public ShouldSerialize/ClearValue methods. We could just look // for public methods in the first place, but then authors might get confused as // to why their non-public method didn't get found, especially because the CLR // TypeDescriptor does find and use non-public methods. if (!methodInfo.IsPublic) { throw new InvalidOperationException(SR.Get(SRID.SpecialMethodMustBePublic, methodInfo.Name)); } } return(methodInfo); }
internal static string GetLocalizedFailureCodeMessageWithDefault(RightsManagementFailureCode failureCode) { string errorMessage = GetLocalizedFailureCodeMessage(failureCode); if (errorMessage != null) { return(errorMessage); } else { return(SR.Get(SRID.RmExceptionGenericMessage)); } }
/// <summary> /// Replaces matrix with the inverse of the transformation. This will throw an InvalidOperationException /// if !HasInverse /// </summary> /// <exception cref="InvalidOperationException"> /// This will throw an InvalidOperationException if the matrix is non-invertable /// </exception> public void Invert() { double determinant = Determinant; if (DoubleUtil.IsZero(determinant)) { throw new System.InvalidOperationException(SR.Get(SRID.Transform_NotInvertible)); } // Inversion does not change the type of a matrix. switch (_type) { case MatrixTypes.TRANSFORM_IS_IDENTITY: break; case MatrixTypes.TRANSFORM_IS_SCALING: { _m11 = 1.0 / _m11; _m22 = 1.0 / _m22; } break; case MatrixTypes.TRANSFORM_IS_TRANSLATION: _offsetX = -_offsetX; _offsetY = -_offsetY; break; case MatrixTypes.TRANSFORM_IS_SCALING | MatrixTypes.TRANSFORM_IS_TRANSLATION: { _m11 = 1.0 / _m11; _m22 = 1.0 / _m22; _offsetX = -_offsetX * _m11; _offsetY = -_offsetY * _m22; } break; default: { double invdet = 1.0 / determinant; SetMatrix(_m22 * invdet, -_m12 * invdet, -_m21 * invdet, _m11 * invdet, (_m21 * _offsetY - _offsetX * _m22) * invdet, (_offsetX * _m12 - _m11 * _offsetY) * invdet, MatrixTypes.TRANSFORM_IS_UNKNOWN); } break; } }
/// <summary> /// Removes activation for a given user. User must have Windows or Passport authnetication /// </summary> public static void RemoveActivatedUser(ContentUser user) { SecurityHelper.DemandRightsManagementPermission(); if (user == null) { throw new ArgumentNullException("user"); } // we only let specifically identifyed users to be used here if ((user.AuthenticationType != AuthenticationType.Windows) && (user.AuthenticationType != AuthenticationType.Passport)) { throw new ArgumentOutOfRangeException("user", SR.Get(SRID.OnlyPassportOrWindowsAuthenticatedUsersAreAllowed)); } // Generic client session to enumerate user certificates using (ClientSession userClientSession = new ClientSession(user)) { // Remove Licensor certificastes first List <string> userClientLicensorCertificateIds = userClientSession.EnumerateUsersCertificateIds(user, EnumerateLicenseFlags.ClientLicensor); // and now we can remove certificates that have been enumerated foreach (string licenseId in userClientLicensorCertificateIds) { userClientSession.DeleteLicense(licenseId); } // Remove User's identity certificastes second List <string> userGroupIdentityCertificateIds = userClientSession.EnumerateUsersCertificateIds(user, EnumerateLicenseFlags.GroupIdentity); // and now we can remove certificates that have been enumerated foreach (string licenseId in userGroupIdentityCertificateIds) { userClientSession.DeleteLicense(licenseId); } } }
/// <summary> /// This property verifies whether the current machine was prepared for consuming and producing RM protected content. /// If property returns true it could be used as an indication that Init function call will not result in a network transaction. /// </summary> public static bool IsUserActivated(ContentUser user) { SecurityHelper.DemandRightsManagementPermission(); if (user == null) { throw new ArgumentNullException("user"); } // we only let specifically identified users to be used here if ((user.AuthenticationType != AuthenticationType.Windows) && (user.AuthenticationType != AuthenticationType.Passport)) { throw new ArgumentOutOfRangeException("user", SR.Get(SRID.OnlyPassportOrWindowsAuthenticatedUsersAreAllowed)); } using (ClientSession userClientSession = new ClientSession(user)) { // if machine activation is not present we can return false right away return(userClientSession.IsMachineActivated() && userClientSession.IsUserActivated()); } }
private static string GetLocalizedFailureCodeMessage(RightsManagementFailureCode failureCode) { string result; switch (failureCode) { case RightsManagementFailureCode.InvalidLicense: result = SRID.RmExceptionInvalidLicense; break; case RightsManagementFailureCode.InfoNotInLicense: result = SRID.RmExceptionInfoNotInLicense; break; case RightsManagementFailureCode.InvalidLicenseSignature: result = SRID.RmExceptionInvalidLicenseSignature; break; case RightsManagementFailureCode.EncryptionNotPermitted: result = SRID.RmExceptionEncryptionNotPermitted; break; case RightsManagementFailureCode.RightNotGranted: result = SRID.RmExceptionRightNotGranted; break; case RightsManagementFailureCode.InvalidVersion: result = SRID.RmExceptionInvalidVersion; break; case RightsManagementFailureCode.InvalidEncodingType: result = SRID.RmExceptionInvalidEncodingType; break; case RightsManagementFailureCode.InvalidNumericalValue: result = SRID.RmExceptionInvalidNumericalValue; break; case RightsManagementFailureCode.InvalidAlgorithmType: result = SRID.RmExceptionInvalidAlgorithmType; break; case RightsManagementFailureCode.EnvironmentNotLoaded: result = SRID.RmExceptionEnvironmentNotLoaded; break; case RightsManagementFailureCode.EnvironmentCannotLoad: result = SRID.RmExceptionEnvironmentCannotLoad; break; case RightsManagementFailureCode.TooManyLoadedEnvironments: result = SRID.RmExceptionTooManyLoadedEnvironments; break; case RightsManagementFailureCode.IncompatibleObjects: result = SRID.RmExceptionIncompatibleObjects; break; case RightsManagementFailureCode.LibraryFail: result = SRID.RmExceptionLibraryFail; break; case RightsManagementFailureCode.EnablingPrincipalFailure: result = SRID.RmExceptionEnablingPrincipalFailure; break; case RightsManagementFailureCode.InfoNotPresent: result = SRID.RmExceptionInfoNotPresent; break; case RightsManagementFailureCode.BadGetInfoQuery: result = SRID.RmExceptionBadGetInfoQuery; break; case RightsManagementFailureCode.KeyTypeUnsupported: result = SRID.RmExceptionKeyTypeUnsupported; break; case RightsManagementFailureCode.CryptoOperationUnsupported: result = SRID.RmExceptionCryptoOperationUnsupported; break; case RightsManagementFailureCode.ClockRollbackDetected: result = SRID.RmExceptionClockRollbackDetected; break; case RightsManagementFailureCode.QueryReportsNoResults: result = SRID.RmExceptionQueryReportsNoResults; break; case RightsManagementFailureCode.UnexpectedException: result = SRID.RmExceptionUnexpectedException; break; case RightsManagementFailureCode.BindValidityTimeViolated: result = SRID.RmExceptionBindValidityTimeViolated; break; case RightsManagementFailureCode.BrokenCertChain: result = SRID.RmExceptionBrokenCertChain; break; case RightsManagementFailureCode.BindPolicyViolation: result = SRID.RmExceptionBindPolicyViolation; break; case RightsManagementFailureCode.ManifestPolicyViolation: result = SRID.RmExceptionManifestPolicyViolation; break; case RightsManagementFailureCode.BindRevokedLicense: result = SRID.RmExceptionBindRevokedLicense; break; case RightsManagementFailureCode.BindRevokedIssuer: result = SRID.RmExceptionBindRevokedIssuer; break; case RightsManagementFailureCode.BindRevokedPrincipal: result = SRID.RmExceptionBindRevokedPrincipal; break; case RightsManagementFailureCode.BindRevokedResource: result = SRID.RmExceptionBindRevokedResource; break; case RightsManagementFailureCode.BindRevokedModule: result = SRID.RmExceptionBindRevokedModule; break; case RightsManagementFailureCode.BindContentNotInEndUseLicense: result = SRID.RmExceptionBindContentNotInEndUseLicense; break; case RightsManagementFailureCode.BindAccessPrincipalNotEnabling: result = SRID.RmExceptionBindAccessPrincipalNotEnabling; break; case RightsManagementFailureCode.BindAccessUnsatisfied: result = SRID.RmExceptionBindAccessUnsatisfied; break; case RightsManagementFailureCode.BindIndicatedPrincipalMissing: result = SRID.RmExceptionBindIndicatedPrincipalMissing; break; case RightsManagementFailureCode.BindMachineNotFoundInGroupIdentity: result = SRID.RmExceptionBindMachineNotFoundInGroupIdentity; break; case RightsManagementFailureCode.LibraryUnsupportedPlugIn: result = SRID.RmExceptionLibraryUnsupportedPlugIn; break; case RightsManagementFailureCode.BindRevocationListStale: result = SRID.RmExceptionBindRevocationListStale; break; case RightsManagementFailureCode.BindNoApplicableRevocationList: result = SRID.RmExceptionBindNoApplicableRevocationList; break; case RightsManagementFailureCode.InvalidHandle: result = SRID.RmExceptionInvalidHandle; break; case RightsManagementFailureCode.BindIntervalTimeViolated: result = SRID.RmExceptionBindIntervalTimeViolated; break; case RightsManagementFailureCode.BindNoSatisfiedRightsGroup: result = SRID.RmExceptionBindNoSatisfiedRightsGroup; break; case RightsManagementFailureCode.BindSpecifiedWorkMissing: result = SRID.RmExceptionBindSpecifiedWorkMissing; break; case RightsManagementFailureCode.NoMoreData: result = SRID.RmExceptionNoMoreData; break; case RightsManagementFailureCode.LicenseAcquisitionFailed: result = SRID.RmExceptionLicenseAcquisitionFailed; break; case RightsManagementFailureCode.IdMismatch: result = SRID.RmExceptionIdMismatch; break; case RightsManagementFailureCode.TooManyCertificates: result = SRID.RmExceptionTooManyCertificates; break; case RightsManagementFailureCode.NoDistributionPointUrlFound: result = SRID.RmExceptionNoDistributionPointUrlFound; break; case RightsManagementFailureCode.AlreadyInProgress: result = SRID.RmExceptionAlreadyInProgress; break; case RightsManagementFailureCode.GroupIdentityNotSet: result = SRID.RmExceptionGroupIdentityNotSet; break; case RightsManagementFailureCode.RecordNotFound: result = SRID.RmExceptionRecordNotFound; break; case RightsManagementFailureCode.NoConnect: result = SRID.RmExceptionNoConnect; break; case RightsManagementFailureCode.NoLicense: result = SRID.RmExceptionNoLicense; break; case RightsManagementFailureCode.NeedsMachineActivation: result = SRID.RmExceptionNeedsMachineActivation; break; case RightsManagementFailureCode.NeedsGroupIdentityActivation: result = SRID.RmExceptionNeedsGroupIdentityActivation; break; case RightsManagementFailureCode.ActivationFailed: result = SRID.RmExceptionActivationFailed; break; case RightsManagementFailureCode.Aborted: result = SRID.RmExceptionAborted; break; case RightsManagementFailureCode.OutOfQuota: result = SRID.RmExceptionOutOfQuota; break; case RightsManagementFailureCode.AuthenticationFailed: result = SRID.RmExceptionAuthenticationFailed; break; case RightsManagementFailureCode.ServerError: result = SRID.RmExceptionServerError; break; case RightsManagementFailureCode.InstallationFailed: result = SRID.RmExceptionInstallationFailed; break; case RightsManagementFailureCode.HidCorrupted: result = SRID.RmExceptionHidCorrupted; break; case RightsManagementFailureCode.InvalidServerResponse: result = SRID.RmExceptionInvalidServerResponse; break; case RightsManagementFailureCode.ServiceNotFound: result = SRID.RmExceptionServiceNotFound; break; case RightsManagementFailureCode.UseDefault: result = SRID.RmExceptionUseDefault; break; case RightsManagementFailureCode.ServerNotFound: result = SRID.RmExceptionServerNotFound; break; case RightsManagementFailureCode.InvalidEmail: result = SRID.RmExceptionInvalidEmail; break; case RightsManagementFailureCode.ValidityTimeViolation: result = SRID.RmExceptionValidityTimeViolation; break; case RightsManagementFailureCode.OutdatedModule: result = SRID.RmExceptionOutdatedModule; break; case RightsManagementFailureCode.ServiceMoved: result = SRID.RmExceptionServiceMoved; break; case RightsManagementFailureCode.ServiceGone: result = SRID.RmExceptionServiceGone; break; case RightsManagementFailureCode.AdEntryNotFound: result = SRID.RmExceptionAdEntryNotFound; break; case RightsManagementFailureCode.NotAChain: result = SRID.RmExceptionNotAChain; break; case RightsManagementFailureCode.RequestDenied: result = SRID.RmExceptionRequestDenied; break; case RightsManagementFailureCode.NotSet: result = SRID.RmExceptionNotSet; break; case RightsManagementFailureCode.MetadataNotSet: result = SRID.RmExceptionMetadataNotSet; break; case RightsManagementFailureCode.RevocationInfoNotSet: result = SRID.RmExceptionRevocationInfoNotSet; break; case RightsManagementFailureCode.InvalidTimeInfo: result = SRID.RmExceptionInvalidTimeInfo; break; case RightsManagementFailureCode.RightNotSet: result = SRID.RmExceptionRightNotSet; break; case RightsManagementFailureCode.LicenseBindingToWindowsIdentityFailed: result = SRID.RmExceptionLicenseBindingToWindowsIdentityFailed; break; case RightsManagementFailureCode.InvalidIssuanceLicenseTemplate: result = SRID.RmExceptionInvalidIssuanceLicenseTemplate; break; case RightsManagementFailureCode.InvalidKeyLength: result = SRID.RmExceptionInvalidKeyLength; break; case RightsManagementFailureCode.ExpiredOfficialIssuanceLicenseTemplate: result = SRID.RmExceptionExpiredOfficialIssuanceLicenseTemplate; break; case RightsManagementFailureCode.InvalidClientLicensorCertificate: result = SRID.RmExceptionInvalidClientLicensorCertificate; break; case RightsManagementFailureCode.HidInvalid: result = SRID.RmExceptionHidInvalid; break; case RightsManagementFailureCode.EmailNotVerified: result = SRID.RmExceptionEmailNotVerified; break; case RightsManagementFailureCode.DebuggerDetected: result = SRID.RmExceptionDebuggerDetected; break; case RightsManagementFailureCode.InvalidLockboxType: result = SRID.RmExceptionInvalidLockboxType; break; case RightsManagementFailureCode.InvalidLockboxPath: result = SRID.RmExceptionInvalidLockboxPath; break; case RightsManagementFailureCode.InvalidRegistryPath: result = SRID.RmExceptionInvalidRegistryPath; break; case RightsManagementFailureCode.NoAesCryptoProvider: result = SRID.RmExceptionNoAesCryptoProvider; break; case RightsManagementFailureCode.GlobalOptionAlreadySet: result = SRID.RmExceptionGlobalOptionAlreadySet; break; case RightsManagementFailureCode.OwnerLicenseNotFound: result = SRID.RmExceptionOwnerLicenseNotFound; break; default: return(null); } return(SR.Get(result)); }