< Summary - CoreWCF Coverage — PR #1766

Information
Class: CoreWCF.IdentityModel.Claims.WindowsClaimSet
Assembly: CoreWCF.Primitives
File(s): /home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/IdentityModel/Claims/WindowsClaimSet.cs
Line coverage
12%
Covered lines: 17
Uncovered lines: 121
Coverable lines: 138
Total lines: 364
Line coverage: 12.3%
Branch coverage
5%
Covered branches: 6
Total branches: 108
Branch coverage: 5.5%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)100%110%
.ctor(...)0%440%
.ctor(...)50%6683.33%
.ctor(...)100%11100%
.ctor(...)33.33%6660%
.ctor(...)100%110%
Clone()100%110%
Dispose()0%440%
InitializeClaimsCore()0%880%
EnsureClaims()0%220%
AddClaim(...)100%110%
ThrowIfDisposed()50%2266.66%
SupportedClaimType(...)0%880%
FindClaims()0%48480%
GetEnumerator()100%110%
ToString()0%220%
TryCreateWindowsSidClaim(...)0%440%
.ctor(...)0%12120%

File(s)

/home/runner/work/CoreWCF/CoreWCF/src/CoreWCF.Primitives/src/CoreWCF/IdentityModel/Claims/WindowsClaimSet.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Collections.ObjectModel;
 7using System.Security.Claims;
 8using System.Security.Principal;
 9using CoreWCF.IdentityModel.Policy;
 10using CoreWCF.Security;
 11
 12namespace CoreWCF.IdentityModel.Claims
 13{
 14    public class WindowsClaimSet : ClaimSet, IIdentityInfo, IDisposable
 15    {
 16        internal const bool DefaultIncludeWindowsGroups = true;
 17        private readonly ClaimsIdentity _windowsIdentity;
 18        private readonly bool _includeWindowsGroups;
 19        private IList<Claim> _claims;
 20        private bool _disposed = false;
 21        private readonly string _authenticationType;
 22        GroupSidClaimCollection _groups;
 23        LdapSettings _ldapSettings;
 24
 25        public WindowsClaimSet(WindowsIdentity windowsIdentity)
 026            : this(windowsIdentity, DefaultIncludeWindowsGroups)
 27        {
 028        }
 29
 30        public WindowsClaimSet(WindowsIdentity windowsIdentity, bool includeWindowsGroups)
 031            : this(windowsIdentity, includeWindowsGroups, DateTime.UtcNow.AddHours(10))
 32        {
 033        }
 34
 35        public WindowsClaimSet(WindowsIdentity windowsIdentity, DateTime expirationTime)
 036            : this(windowsIdentity, DefaultIncludeWindowsGroups, expirationTime)
 37        {
 038        }
 39
 40        public WindowsClaimSet(WindowsIdentity windowsIdentity, bool includeWindowsGroups, DateTime expirationTime)
 041            : this(windowsIdentity, null, includeWindowsGroups, expirationTime, true)
 42        {
 043        }
 44
 45        public WindowsClaimSet(WindowsIdentity windowsIdentity, string authenticationType, bool includeWindowsGroups, Da
 046            : this(windowsIdentity, authenticationType, includeWindowsGroups, expirationTime, true)
 47        {
 048        }
 49
 50        internal WindowsClaimSet(WindowsIdentity windowsIdentity, string authenticationType, bool includeWindowsGroups, 
 051            : this(windowsIdentity, authenticationType, includeWindowsGroups, DateTime.UtcNow.AddHours(10), clone)
 52        {
 053        }
 54
 55        internal WindowsClaimSet(WindowsIdentity windowsIdentity, string authenticationType, bool includeWindowsGroups, 
 056            : this(windowsIdentity, authenticationType, includeWindowsGroups, expirationTime, clone, null)
 57        {
 58
 059        }
 60
 61        internal WindowsClaimSet(WindowsIdentity windowsIdentity, string authenticationType, bool includeWindowsGroups, 
 062            : this(authenticationType, includeWindowsGroups, expirationTime, clone, _fromClaims)
 63        {
 064            if (windowsIdentity == null)
 65            {
 066                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(windowsIdentity));
 67            }
 68
 069            _windowsIdentity = clone ? SecurityUtils.CloneWindowsIdentityIfNecessary(windowsIdentity, authenticationType
 070        }
 71
 72        internal WindowsClaimSet(ClaimsIdentity claimsIdentity, string authenticationType, bool includeWindowsGroups, Da
 173            : this(authenticationType, includeWindowsGroups, expirationTime, clone, _fromClaims)
 74        {
 175            if (claimsIdentity == null)
 76            {
 077                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(claimsIdentity));
 78            }
 179            _windowsIdentity = (clone && claimsIdentity is WindowsIdentity) ? SecurityUtils.CloneWindowsIdentityIfNecess
 180            _ldapSettings = ldapSettings;
 181        }
 82
 83       internal WindowsClaimSet(ClaimsIdentity claimsIdentity, bool includeWindowsGroups,  LdapSettings ldapSettings)
 184        : this(claimsIdentity, null, includeWindowsGroups, DateTime.UtcNow.AddHours(10), false, null,ldapSettings)
 85        {
 186        }
 87
 188        private WindowsClaimSet(string authenticationType, bool includeWindowsGroups, DateTime expirationTime, bool clon
 89        {
 190            _includeWindowsGroups = includeWindowsGroups;
 191            ExpirationTime = expirationTime;
 192            _authenticationType = authenticationType;
 193            if (_fromClaims != null && _fromClaims.Count > 0)
 94            {
 095                List<Claim> allClaims = new List<Claim>();
 096                foreach (Claim claim in _fromClaims)
 97                {
 098                    allClaims.Add(claim);
 99                }
 0100                _claims = allClaims;
 101            }
 1102        }
 103
 104        private WindowsClaimSet(WindowsClaimSet from)
 0105            : this(from.WindowsIdentity, from._authenticationType, from._includeWindowsGroups, from.ExpirationTime, true
 106        {
 0107        }
 108
 109        public override Claim this[int index]
 110        {
 111            get
 112            {
 0113                ThrowIfDisposed();
 0114                EnsureClaims();
 0115                return _claims[index];
 116            }
 117        }
 118
 119        public override int Count
 120        {
 121            get
 122            {
 0123                ThrowIfDisposed();
 0124                EnsureClaims();
 0125                return _claims.Count;
 126            }
 127        }
 128
 129        IIdentity IIdentityInfo.Identity
 130        {
 131            get
 132            {
 1133                ThrowIfDisposed();
 1134                return _windowsIdentity;
 135            }
 136        }
 137
 138        public ClaimsIdentity WindowsIdentity
 139        {
 140            get
 141            {
 0142                ThrowIfDisposed();
 0143                return _windowsIdentity;
 144            }
 145        }
 146
 147        public override ClaimSet Issuer
 148        {
 0149            get { return Windows; }
 150        }
 151
 0152        public DateTime ExpirationTime { get; }
 153
 154        GroupSidClaimCollection Groups
 155        {
 156            get
 157            {
 0158                if (this._groups == null)
 159                {
 0160                    this._groups = new GroupSidClaimCollection(_windowsIdentity, _ldapSettings);
 161                }
 0162                return this._groups;
 163            }
 164        }
 165
 166        internal WindowsClaimSet Clone()
 167        {
 0168            ThrowIfDisposed();
 0169            return new WindowsClaimSet(this);
 170        }
 171
 172        public void Dispose()
 173        {
 0174            if (!_disposed)
 175            {
 0176                _disposed = true;
 0177                if(_windowsIdentity is WindowsIdentity)
 0178                    ((WindowsIdentity)_windowsIdentity).Dispose();
 179            }
 0180        }
 181
 182        private IList<Claim> InitializeClaimsCore()
 183        {
 0184            List<Claim> claims = new List<Claim>();
 0185            if (_windowsIdentity is WindowsIdentity)
 186            {
 0187                WindowsIdentity _windowsInternalIdentity = (WindowsIdentity)_windowsIdentity;
 0188                if (_windowsInternalIdentity.AccessToken == null)
 189                {
 0190                    return new List<Claim>();
 191                }
 192
 0193                claims.Add(new Claim(ClaimTypes.Sid, _windowsInternalIdentity.User, Rights.Identity));
 0194                if (TryCreateWindowsSidClaim(_windowsInternalIdentity, out Claim claim))
 195                {
 0196                    claims.Add(claim);
 197                }
 0198                claims.Add(Claim.CreateNameClaim(_windowsIdentity.Name));
 199            }
 200            else
 201            {
 0202                claims.Add(Claim.CreateNameClaim(_windowsIdentity.Name));
 203            }
 204
 0205            if (_includeWindowsGroups)
 206            {
 0207                claims.AddRange(Groups);
 208            }
 0209            return claims;
 210        }
 211
 212        private void EnsureClaims()
 213        {
 0214            if (_claims != null)
 215            {
 0216                return;
 217            }
 218
 0219            _claims = InitializeClaimsCore();
 0220        }
 221
 222        public void AddClaim(Claim claim)
 223        {
 0224            _claims.Add(claim);
 0225        }
 226
 227        private void ThrowIfDisposed()
 228        {
 1229            if (_disposed)
 230            {
 0231                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ObjectDisposedException(GetType().FullName
 232            }
 1233        }
 234
 235        private static bool SupportedClaimType(string claimType)
 236        {
 0237            return claimType == null ||
 0238                ClaimTypes.Sid == claimType ||
 0239                ClaimTypes.DenyOnlySid == claimType ||
 0240                ClaimTypes.Role == claimType ||
 0241                ClaimTypes.Name == claimType;
 242        }
 243
 244        // Note: null string represents any.
 245        public override IEnumerable<Claim> FindClaims(string claimType, string right)
 246        {
 0247            ThrowIfDisposed();
 0248            if (!SupportedClaimType(claimType) || !SupportedRight(right))
 249            {
 0250                yield break;
 251            }
 0252            else if (_claims == null && _windowsIdentity is WindowsIdentity && (ClaimTypes.Sid == claimType || ClaimType
 253            {
 0254                if (ClaimTypes.Sid == claimType)
 255                {
 0256                    if (right == null || Rights.Identity == right)
 257                    {
 0258                        yield return new Claim(ClaimTypes.Sid, ((WindowsIdentity)_windowsIdentity).User, Rights.Identity
 259                    }
 260                }
 261
 0262                if (right == null || Rights.PossessProperty == right)
 263                {
 0264                    if (TryCreateWindowsSidClaim((WindowsIdentity)_windowsIdentity, out Claim sid))
 265                    {
 0266                        if (claimType == sid.ClaimType)
 267                        {
 0268                            yield return sid;
 269                        }
 270                    }
 271                }
 272
 0273                if (_includeWindowsGroups && (right == null || Rights.PossessProperty == right))
 274                {
 0275                    for (int i = 0; i < this.Groups.Count; ++i)
 276                    {
 0277                        Claim sid = this.Groups[i];
 0278                        if (claimType == sid.ClaimType)
 279                        {
 0280                            yield return sid;
 281                        }
 282                    }
 283                }
 284            }
 285            else
 286            {
 0287                EnsureClaims();
 288
 0289                bool anyClaimType = (claimType == null);
 0290                bool anyRight = (right == null);
 291
 0292                for (int i = 0; i < _claims.Count; ++i)
 293                {
 0294                    Claim claim = _claims[i];
 0295                    if ((claim != null) &&
 0296                        (anyClaimType || claimType == claim.ClaimType) &&
 0297                        (anyRight || right == claim.Right))
 298                    {
 0299                        yield return claim;
 300                    }
 301                }
 302            }
 0303        }
 304
 305        public override IEnumerator<Claim> GetEnumerator()
 306        {
 0307            ThrowIfDisposed();
 0308            EnsureClaims();
 0309            return _claims.GetEnumerator();
 310        }
 311
 312        public override string ToString()
 313        {
 0314            return _disposed ? base.ToString() : SecurityUtils.ClaimSetToString(this);
 315        }
 316
 317        public static bool TryCreateWindowsSidClaim(WindowsIdentity windowsIdentity, out Claim claim)
 318        {
 0319            if (windowsIdentity.User != null && windowsIdentity.User.IsAccountSid())
 320            {
 0321                claim = Claim.CreateWindowsSidClaim(new SecurityIdentifier(windowsIdentity.User.Value));
 0322                return true;
 323            }
 0324            claim = null;
 0325            return false;
 326        }
 327
 328        class GroupSidClaimCollection : Collection<Claim>
 329        {
 0330            public GroupSidClaimCollection(ClaimsIdentity claimsIdentity, LdapSettings ldapSettings)
 331            {
 0332                if(claimsIdentity is WindowsIdentity)
 333                {
 0334                    var windowsIdentity = (WindowsIdentity)claimsIdentity;
 0335                    if (windowsIdentity.Token != IntPtr.Zero)
 336                    {
 0337                        foreach (var groupId in windowsIdentity.Groups)
 338                        {
 0339                            var group = groupId.Translate(typeof(NTAccount));
 0340                            string[] domainGroups = group.Value.Split(new char[] { '\\' });
 0341                            if (domainGroups.Length > 1)
 342                            {
 0343                                base.Add(new Claim(ClaimTypes.Role, domainGroups[1], Rights.Identity));
 344                            }
 345                            else
 346                            {
 0347                                base.Add(new Claim(ClaimTypes.Role, group, Rights.Identity));
 348                            }
 349                        }
 350                    }
 351                }
 0352                else if(ldapSettings !=null)
 353                {
 0354                    List<Claim> allClaims = LdapAdapter.RetrieveClaimsAsync(ldapSettings, claimsIdentity.Name).GetAwaite
 0355                    foreach(Claim roleClaim in allClaims)
 356                    {
 0357                        base.Add(roleClaim);
 358                    }
 359                }
 360
 0361            }
 362        }
 363    }
 364}
Generated by: ReportGenerator 5.5.11.0
08/09/2026 - 10:15:49
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.Security.Principal.WindowsIdentity)
.ctor(System.Security.Principal.WindowsIdentity,System.Boolean)
.ctor(System.Security.Principal.WindowsIdentity,System.DateTime)
.ctor(System.Security.Principal.WindowsIdentity,System.Boolean,System.DateTime)
.ctor(System.Security.Principal.WindowsIdentity,System.String,System.Boolean,System.DateTime)
.ctor(System.Security.Principal.WindowsIdentity,System.String,System.Boolean,System.Boolean)
.ctor(System.Security.Principal.WindowsIdentity,System.String,System.Boolean,System.DateTime,System.Boolean)
.ctor(System.Security.Principal.WindowsIdentity,System.String,System.Boolean,System.DateTime,System.Boolean,System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Claims.Claim>)
.ctor(System.Security.Claims.ClaimsIdentity,System.String,System.Boolean,System.DateTime,System.Boolean,System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Claims.Claim>,CoreWCF.Security.LdapSettings)
.ctor(System.Security.Claims.ClaimsIdentity,System.Boolean,CoreWCF.Security.LdapSettings)
.ctor(System.String,System.Boolean,System.DateTime,System.Boolean,System.Collections.Generic.IList`1<CoreWCF.IdentityModel.Claims.Claim>)
.ctor(CoreWCF.IdentityModel.Claims.WindowsClaimSet)
Item(System.Int32)
Count()
WCF.IdentityModel.Policy.IIdentityInfo.get_Identity()
WindowsIdentity()
Issuer()
ExpirationTime()
Groups()
Clone()
Dispose()
InitializeClaimsCore()
EnsureClaims()
AddClaim(CoreWCF.IdentityModel.Claims.Claim)
ThrowIfDisposed()
SupportedClaimType(System.String)
FindClaims()
GetEnumerator()
ToString()
TryCreateWindowsSidClaim(System.Security.Principal.WindowsIdentity,CoreWCF.IdentityModel.Claims.Claim&)
.ctor(System.Security.Claims.ClaimsIdentity,CoreWCF.Security.LdapSettings)