Szoftverfejlesztés .NET platformon - Jegyzet 12. fejezet

A VIK Wikiből
A lap korábbi változatát látod, amilyen Hryghr (vitalap | szerkesztései) 2013. május 19., 22:25-kor történt szerkesztése után volt. (Hryghr átnevezte a(z) Szoftverfejlesztés .NET plattformon - Jegyzet 12. fejezet lapot a következő névre: Szoftverfejlesztés .NET platformon - Jegyzet 12. fejezet: pontos név)
(eltér) ← Régebbi változat | Aktuális változat (eltér) | Újabb változat→ (eltér)
Ugrás a navigációhoz Ugrás a kereséshez

Ez az oldal a korábbi SCH wiki-ről lett áthozva. Az eredeti változata itt érhető el.

Ha úgy érzed, hogy bármilyen formázási vagy tartalmi probléma van vele, akkor kérlek javíts rajta egy rövid szerkesztéssel.

Ha nem tudod, hogyan indulj el, olvasd el a migrálási útmutatót


70-536 .NET Framework 2.0 Application Development Foundation

%TOC{depth="3"}%

User Security

RBS = Role-Based Security
ACL = Access Control List: pl. NTFS file rendszer jogok

=WindowsIdentity=: a Windows accountokat reprezentálja. Felhasználót nem tud authentikálni, csak a belépett felhasználóról ad információkat.

  • =static WindowsIdentity GetCurrent()=: aktuális felhasználó lekérdezése
  • =static WindowsIdentity GetAnonymous()=: anonymous felhasználó lekérdezése
  • =static WindowsImpersonationContext Impersonate()=: felhasználót személyesít meg
  • =IsAnonymous=: névtelen-e
  • =IsAuthenticated=: be van-e jelentkezve
  • =IsGuest=: vendég-e
  • =IsSystem=: part of the operating system szerepkörbe tartozik
  • =Name=: "domain\felhasználónév"
  • =AuthenticationType=: hogyan authentikált (általában NTLM)
  • =Token=: biztonsági token

=WindowsPrincipal=: a felhasználó milyen csoportokba tartozik bele.

WindowsIdentity

-k segítségével lehet a legkönnyebben megszerezni.

  • =WindowsPrincipal currentPrincipal = new WindowsPrincipal(WindowsIdentity.GetCurrent());=
  • =AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);=

=WindowsPrincipal currentPrincipal = (WindowsPrincipal)Thread.CurrentPrincipal;=

  • =IsInRole()=: a felhasználó adott szerepben (pl. =(WindowsBuiltInRole.Administrator=,

=WindowsBuiltInRole.PowerUser= vagy =WindowsBuiltInRole.User=) van-e

  • =PrincipalPermission[Attribute]=: joga van-e valakinek valamihez (imperatív / deklaratív)
    • =Authenticated=: authentikálva van-e a felhasználó
    • =Name=: felhasználó neve
    • =Role=: felhasználó szerepe
    • =Demand()=: jog imperatív ellenőrzése, ha nem sikerül, =Exception=

Deklaratív RBS

Fő hátránya, hogy csak metódusra használható, és a hívónak el kell kapnia az exceptiont, ami esemény esetén lehet a Windows is.

  1. =AppDomain.CurrentDomain.SetPrincipalPolicy()=: milyen policy-t használjunk az appdomain-ben
  2. =try-catch= blokkal elkapjuk a nem jogosult hívásokból adódó
    SecurityException
    -t
  3. =PrincipalPermission= attribútumokkal deklaráljuk a metódus a hívás feltételeit. Például:

=[PrincipalPermission(SecurityAction.Demand, Role = @"BUILTIN\Administrators")]=

Imperatív RBS

Kisebb granularitással lehet szabályozni az egyes kódrészletekhez való hozzáférést.

  1. =AppDomain.CurrentDomain.SetPrincipalPolicy()=: milyen policy-t használjunk az appdomain-ben
  2. =try-catch= blokkal elkapjuk a nem jogosult hívásokból adódó
    SecurityException
    -t
  3. =PrincipalPermission= objektumban deklaráljuk a metódus a hívás feltételeit
    • =PrincipalPermission(PermissionState)=
    • =PrincipalPermission(name, role)=: a name =Environment.MachineName= + @"\felhasználónév" formájú
    • =PrincipalPermission(name, role, authenticated)=
    • nem fontos paraméterek: =null=
  1. =PrincipalPermission.Demand()=
AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.WindowsPrincipal);
string role = Environment.MachineName + @"\VS Developers";
try {
	 PrincipalPermission pp = new PrincipalPermission(null, role, true);
	 pp.Demand();
	 Console.WriteLine("Access allowed.");
	 // TODO: Main application
} catch(Security.SecurityException ex) {
	 Console.WriteLine("Access denied: " + ex.Message);
	 // TODO: Log error
}

Egyedi felhasználók és szerepek

Identity implementálása

  • =System.Security.IIdentity= interfész implementálásával
    • kötelező property-k: =AuthenticationType=, =IsAuthenticated=, =Name=
    • opcioniális property-k: cím, telefonszám, stb.
    • kell egy konstruktor, ami az összes property értékét megkapja argumentumként
  • =GenericIdentity : IIdentity= leszármaztatásával
  • =WindowsIdentity=, =FormsIdentity=, =PassportIdentity=, stb. leszármaztatásával

Principal implementálása

  • =IPrincipal= interfész implementálásával
    • =konstruktor(IIdentity identity, string[] roles)=
    • =IPrincipal Identity { get; }=
    • =bool IsInRole(string role)=
    • opcionálisan
      • =Roles=: visszaadja a szerepek listáját, amiben a felhasználó benne van
      • =IsInAllRoles=, =IsInAnyRole=
      • =IsHigherThanRole=, =IsLowerThanRole=: hierarchikus szereprendszer építhető ki velük
  • =GenericPrincipal : IPrincipal= leszármaztatásával
  • =WindowsPrincipal= leszármaztatásával

Principal beállítása: =Thread.CurrentPrincipal= = ...

Távoli authentikáció

Exception

-ök távoli authentikációkor (pl. SSL)

  • =AuthenticationException=: másfajta authentikáció kell, a stream nyitva marad
  • =InvalidCredentialException=: a stream is lezáródik

Access Control List

ACL fajtái

  • DACL = Discretionary Access Control List: user/group milyen erőforrásokhoz férhet hozzá
    • ACE-kből (Access Control Entry-kből) áll
    • öröklődik
    • felhasználó akkor jogosult valamire, ha az egyik csoportja jogosult,

de egyikben sem tiltják explicit módon

  • SACL = Security ACL.

Célja a logolás, aminek segítségével detektálhatók a hibás biztonsági beállítások és a behatolások.

    • nem engedélyez vagy tilt
    • ahol a DACL tilt, ott az SACL auditál
    • Sikeres objektum (pl. file vagy mappa) hozzáférés esetén bekerül egy SuccessAudit bejegyzés az

Event Logba (ha be van kapcsolva a logolás)

    • A Windows alapból nem auditál, ehhez be kell kapcsolni az Administrative Tools-on belül a

Local Security Policy ablakban.

ACL-ek kezelése felügyelt kódból

  • =System.Security.AccessControl= névtér
  • Minden erőforrás típusra (DirectorySecurity, FileSecurity, RegistrySecurity, stb.)
    • =<type>Security=
    • =<type>AccessRule=: DACL-t reprezentálja
    • =<type>AuditRule=: SACL-t reprezentálja
DirectorySecurity dirSec = new DirectorySecurity(@"dir", AccessControlSections.All)
AuthorizationRuleCollection arc = dirSec.GetAccessRules(true, true, typeof(NTAccount))
foreach (FileSystemAccessRule fsAccRule in arc)
	 Console.WriteLine("{0} {1} {2}",
		  fsAccRule.IdentityReference, fsAccRule.AuditFlags, fsAccRule.FileSystemRights);

Ugyanez eljátszható RegistrySecurity-vel és GetAuditRules hívással is, semmi mást nem kell változtatni.

ACL változtatások véglegesítése:

Directory.SetAccessControl(dir, accessRuleCollection);

Data Security

=System.Security.Cryptography= névtér

Szimmetrikus titkosítás

Azonos kulcs mindkét oldalon, előre meg kell osztani.

Algoritmusok

  • DES: könnyen törhető a rövid, 56 bites kulcs miatt
  • TripleDES: 112/156 bit kulcsméret
  • RC2: DES-t váltja le, változtatható a kulcsméret
  • RijndaelManaged (AES): 128 bites, és mivel nem hív natív kódot, partially trusted környezetben is használható. Ha a küldő és a fogadó is legalább Windows XP-t használ, ez a leggyorsabb.

=SymmetricAlgorithm=: a szimmetrikus kulcsú algoritmsok ősosztálya

  • =BlockSize=, =FeedbackSize=, =IV= (initialization vector), =Key=, =KeySize= (bitekben),

=LegalBlockSize=, =LegalKeySizes=, =Mode= (pl. CBC), =Padding=

    • megosztandó: =IV=, =Key= (=Salt=, =NumberOfIterations= nem kell)
  • =CreateEncryptor()=, =CreateDecryptor()=, =GenerateIV()=, =GenerateKey()=, =VaildKeySize()=
  • =Rfc2898DeriveBytes= osztállyal lehet kulcsot generálni jelszóból.

Kell: jelszó, salt, number of iterations

Titkosítás és visszafejtés lépései

  1. =Stream= objektum létrehozása
  2. =SymmetricAlgorithm= létrehozása
  3. =Key= és =IV= meghatározása
  4. =SymmetricAlgorithm.CreateEncryptor()= vagy =CreateDecryptor()=

visszad egy =ICryptoTransform= objektumot

  1. =CryptoStream= létrehozása, amibe beburkoljuk a valódi streamet (mint a tömörítésnél)
  2. Stream
    -ek lezárása
using (FileStream inFile = new FileStream(inFileName, FileMode.Open, FileAccess.Read)) {
	 byte[] fileData = new byte[inFile.Length];
	 inFile.Read(fileData, 0, (int)inFile.Length);
}

SymmetricAlgorithm alg = new RijndaelManaged();
alg.GenerateKey();

using (FileStream outFile = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write)) {
	 ICryptoTransform encryptor = alg.CreateEncryptor();
	 using (CryptoStream encryptStream = new CryptoStream(outFile, encryptor, CryptoStreamMode.Write))				
		  encryptStream.Write(fileData, 0, fileData.Length);
}

Aszimmetrikus titkosítás

Nincs közös titkos információ. Másik neve: nyilvános kulcsú titkosítás. Lassabb, mint a szimmetrikus kulcsú titkosítás.

=AsymmetricAlgorithm= ősosztály

  • =KeyExchangeAlgorithm=
  • =KeySize=
  • =LegalKeySizes=
  • =SignatureAlgorithm=

RSACryptoServiceProvider : AsymmetricAlgorithm

  • Propertyk:
    • =PersistKeyInCsp=: kulcs tárolódjon-e a CSP-ben
    • =UseMachineKeyStore=: a kulcs a felhasználóhoz vagy a géphez legyen köthető
  • Metódusok:
    • =Encrypt()= / =Decrypt()=
    • =ExportParameters(bool)=: kulcsok exportálása XML-be, =true=: a privát kulcsot is exportálja
    • =ImportParameters()=: kulcsok importálása XML-ből
    • =FromXmlString()=: kulcsok importálása XML-t tartalmazó stringből
  • Kulcs részei
    • =D=: privát kulcs
    • =Exponent=, =Modulus=: publikus kulcs részei

Hash

Nemkulcsolt hash algoritmusok

  • absztrakt osztály (implementációs osztály)
  • =MD5= (=MD5CryptoServiceProvider=): 128 bit
  • =RIPEMD160= (=RIPEMD160Managed=): MD5 helyett, 160 bit
  • =SHA1= (=SHA1CryptoServiceProvider=): 160 bit
  • =SHA256= (=SHA256Managed=): 256 bit
  • =SHA384= (=SHA384Managed=): 384 bit
  • =SHA512= (=SHA512Managed=): 512 bit

Kulcsolt hash algoritmusok

  • =HMACSHA1=: bármekkora kulcs, 20 byte-os hash
  • =MACTripleDES=: 8/16/24 byte-os kulcs, 8 byte-os hash

Példa: kulcsolt =HMACSHA1= hash számítása

args[0]

-ból generált kulccsal

byte[] saltValueBytes = Encoding.ASCII.GetBytes("This is my sa1t");
byte[] secretKey = new Rfc2898DeriveBytes(args[0], saltValueBytes).GetBytes(16);
HMACSHA1 myHash = new HMACSHA1(secretKey);
using (FileStream file = new FileStream(args[1], FileMode.Open, FileAccess.Read)) {
	 BinaryReader reader = new BinaryReader(file);
	 myHash.ComputeHash(reader.ReadBytes((int)file.Length));
}
Console.WriteLine(Convert.ToBase64String(myHash.Hash));

Digitális aláírás =RSACryptoServiceProvider= vagy =DSACryptoServiceProvider= használatával

  • =SignData()= / =VerifyData()=:

kiszámolja / ellenőrzi a file digitális aláírását

  • =SignHash()= / =VerifyHash()=:

kiszámolja / ellenőrzi a file hash értékéből számolt digitális aláírását

  • Azért van szükség külön ellenőrző metódusokra, mert az ellenőrzéskor elég a

küldő publikus kulcsát haszálni.

-- Peti - 2007.06.27.