PasswordDeriveBytes.cs source code in C# .NET

                        
Code:
                         / Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / clr / src / BCL / System / Security / Cryptography / PasswordDeriveBytes.cs / 1 / PasswordDeriveBytes.cs
                        

                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 

// 
// PasswordDerivedBytes.cs 
//
 
namespace System.Security.Cryptography {
    using System.IO;
    using System.Runtime.CompilerServices;
    using System.Security.Cryptography.X509Certificates; 
    using System.Text;
    using System.Globalization; 
 
    [System.Runtime.InteropServices.ComVisible(true)]
    public class PasswordDeriveBytes : DeriveBytes { 
        private int             _extraCount;
        private int             _prefix;
        private int             _iterations;
        private byte[]          _baseValue; 
        private byte[]          _extra;
        private byte[]          _salt; 
        private string          _hashName; 
        private byte[]          _password;
        private HashAlgorithm   _hash; 
        private CspParameters   _cspParams;

        private SafeProvHandle _safeProvHandle = null;
        private SafeProvHandle ProvHandle { 
            get {
                if (_safeProvHandle == null) { 
                    lock (this) { 
                        if (_safeProvHandle == null) {
                            SafeProvHandle safeProvHandle = Utils.AcquireProvHandle(_cspParams); 
                            System.Threading.Thread.MemoryBarrier();
                            _safeProvHandle = safeProvHandle;
                        }
                    } 
                }
                return _safeProvHandle; 
            } 
        }
 
        //
        // public constructors
        //
 
        public PasswordDeriveBytes (String strPassword, byte[] rgbSalt) : this (strPassword, rgbSalt, new CspParameters()) {}
 
        public PasswordDeriveBytes (byte[] password, byte[] salt) : this (password, salt, new CspParameters()) {} 

        public PasswordDeriveBytes (string strPassword, byte[] rgbSalt, string strHashName, int iterations) : 
            this (strPassword, rgbSalt, strHashName, iterations, new CspParameters()) {}

        public PasswordDeriveBytes (byte[] password, byte[] salt, string hashName, int iterations) :
            this (password, salt, hashName, iterations, new CspParameters()) {} 

 
        public PasswordDeriveBytes (string strPassword, byte[] rgbSalt, CspParameters cspParams) : 
            this (strPassword, rgbSalt, "SHA1", 100, cspParams) {}
 
        public PasswordDeriveBytes (byte[] password, byte[] salt, CspParameters cspParams) :
            this (password, salt, "SHA1", 100, cspParams) {}

        public PasswordDeriveBytes (string strPassword, byte[] rgbSalt, String strHashName, int iterations, CspParameters cspParams) : 
            this ((new UTF8Encoding(false)).GetBytes(strPassword), rgbSalt, strHashName, iterations, cspParams) {}
 
        public PasswordDeriveBytes (byte[] password, byte[] salt, String hashName, int iterations, CspParameters cspParams) { 
            this.IterationCount = iterations;
            this.Salt = salt; 
            this.HashName = hashName;
            _password = password;
            _cspParams = cspParams;
        } 

        // 
        // public properties 
        //
 
        public String HashName {
            get { return _hashName; }
            set {
                if (_baseValue != null) 
                    throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_PasswordDerivedBytes_ValuesFixed"), "HashName"));
                _hashName = value; 
                _hash = (HashAlgorithm) CryptoConfig.CreateFromName(_hashName); 
            }
        } 

        public int IterationCount {
            get { return _iterations; }
            set { 
                if (_baseValue != null)
                    throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_PasswordDerivedBytes_ValuesFixed"), "IterationCount")); 
                if (value <= 0) 
                    throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
                _iterations = value; 
            }
        }

        public byte[] Salt { 
            get {
                if (_salt == null) 
                    return null; 
                return (byte[]) _salt.Clone();
            } 
            set {
                if (_baseValue != null)
                    throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_PasswordDerivedBytes_ValuesFixed"), "Salt"));
                if (value == null) 
                    _salt = null;
                else 
                    _salt = (byte[]) value.Clone(); 
            }
        } 

        //
        // public methods
        // 

        [Obsolete("Rfc2898DeriveBytes replaces PasswordDeriveBytes for deriving key material from a password and is preferred in new applications.")] 
        public override byte[] GetBytes(int cb) { 
            int         ib = 0;
            byte[]      rgb; 
            byte[]      rgbOut = new byte[cb];

            if (_baseValue == null) {
                ComputeBaseValue(); 
            }
            else if (_extra != null) { 
                ib = _extra.Length - _extraCount; 
                if (ib >= cb) {
                    Buffer.InternalBlockCopy(_extra, _extraCount, rgbOut, 0, cb); 
                    if (ib > cb)
                        _extraCount += cb;
                    else
                        _extra = null; 

                    return rgbOut; 
                } 
                else {
                    // 
                    // Note: The second parameter should really be _extraCount instead
                    // However, changing this would constitute a breaking change compared
                    // to what has shipped in V1.x.
                    // 

                    Buffer.InternalBlockCopy(_extra, ib, rgbOut, 0, ib); 
                    _extra = null; 
                }
            } 

            rgb = ComputeBytes(cb-ib);
            Buffer.InternalBlockCopy(rgb, 0, rgbOut, ib, cb-ib);
            if (rgb.Length + ib > cb) { 
                _extra = rgb;
                _extraCount = cb-ib; 
            } 
            return rgbOut;
        } 

        public override void Reset() {
            _prefix = 0;
            _extra = null; 
            _baseValue = null;
        } 
 
        public byte[] CryptDeriveKey (string algname, string alghashname, int keySize, byte[] rgbIV) {
            if (keySize < 0) 
                throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidKeySize"));

            int algidhash = X509Utils.OidToAlgId(alghashname);
            if (algidhash == 0) 
                throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_InvalidAlgorithm"));
            int algid = X509Utils.OidToAlgId(algname); 
            if (algid == 0) 
                throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_InvalidAlgorithm"));
 
            // Validate the rgbIV array
            if (rgbIV == null)
                throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_InvalidIV"));
            return Utils._CryptDeriveKey(ProvHandle, algid, algidhash, _password, keySize << 16, rgbIV); 
        }
 
        // 
        // private methods
        // 

        private byte[] ComputeBaseValue() {
            _hash.Initialize();
            _hash.TransformBlock(_password, 0, _password.Length, _password, 0); 
            if (_salt != null)
                _hash.TransformBlock(_salt, 0, _salt.Length, _salt, 0); 
            _hash.TransformFinalBlock(new byte[0], 0, 0); 
            _baseValue = _hash.Hash;
            _hash.Initialize(); 

            for (int i=1; i<(_iterations-1); i++) {
                _hash.ComputeHash(_baseValue);
                _baseValue = _hash.Hash; 
            }
            return _baseValue; 
        } 

        private byte[] ComputeBytes(int cb) { 
            int                 cbHash;
            int                 ib = 0;
            byte[]              rgb;
 
            _hash.Initialize();
            cbHash = _hash.HashSize / 8; 
            rgb = new byte[((cb+cbHash-1)/cbHash)*cbHash]; 

            CryptoStream cs = new CryptoStream(Stream.Null, _hash, CryptoStreamMode.Write); 
            HashPrefix(cs);
            cs.Write(_baseValue, 0, _baseValue.Length);
            cs.Close();
            Buffer.InternalBlockCopy(_hash.Hash, 0, rgb, ib, cbHash); 
            ib += cbHash;
 
            while (cb > ib) { 
                _hash.Initialize();
                cs = new CryptoStream(Stream.Null, _hash, CryptoStreamMode.Write); 
                HashPrefix(cs);
                cs.Write(_baseValue, 0, _baseValue.Length);
                cs.Close();
                Buffer.InternalBlockCopy(_hash.Hash, 0, rgb, ib, cbHash); 
                ib += cbHash;
            } 
 
            return rgb;
        } 

        void HashPrefix(CryptoStream cs) {
            int    cb = 0;
            byte[] rgb = {(byte)'0', (byte)'0', (byte)'0'}; 

            if (_prefix > 999) 
                    throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_TooManyBytes")); 

            if (_prefix >= 100) { 
                rgb[0] += (byte) (_prefix /100);
                cb += 1;
            }
            if (_prefix >= 10) { 
                rgb[cb] += (byte) ((_prefix % 100) / 10);
                cb += 1; 
            } 
            if (_prefix > 0) {
                rgb[cb] += (byte) (_prefix % 10); 
                cb += 1;
                cs.Write(rgb, 0, cb);
            }
            _prefix += 1; 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 

// 
// PasswordDerivedBytes.cs 
//
 
namespace System.Security.Cryptography {
    using System.IO;
    using System.Runtime.CompilerServices;
    using System.Security.Cryptography.X509Certificates; 
    using System.Text;
    using System.Globalization; 
 
    [System.Runtime.InteropServices.ComVisible(true)]
    public class PasswordDeriveBytes : DeriveBytes { 
        private int             _extraCount;
        private int             _prefix;
        private int             _iterations;
        private byte[]          _baseValue; 
        private byte[]          _extra;
        private byte[]          _salt; 
        private string          _hashName; 
        private byte[]          _password;
        private HashAlgorithm   _hash; 
        private CspParameters   _cspParams;

        private SafeProvHandle _safeProvHandle = null;
        private SafeProvHandle ProvHandle { 
            get {
                if (_safeProvHandle == null) { 
                    lock (this) { 
                        if (_safeProvHandle == null) {
                            SafeProvHandle safeProvHandle = Utils.AcquireProvHandle(_cspParams); 
                            System.Threading.Thread.MemoryBarrier();
                            _safeProvHandle = safeProvHandle;
                        }
                    } 
                }
                return _safeProvHandle; 
            } 
        }
 
        //
        // public constructors
        //
 
        public PasswordDeriveBytes (String strPassword, byte[] rgbSalt) : this (strPassword, rgbSalt, new CspParameters()) {}
 
        public PasswordDeriveBytes (byte[] password, byte[] salt) : this (password, salt, new CspParameters()) {} 

        public PasswordDeriveBytes (string strPassword, byte[] rgbSalt, string strHashName, int iterations) : 
            this (strPassword, rgbSalt, strHashName, iterations, new CspParameters()) {}

        public PasswordDeriveBytes (byte[] password, byte[] salt, string hashName, int iterations) :
            this (password, salt, hashName, iterations, new CspParameters()) {} 

 
        public PasswordDeriveBytes (string strPassword, byte[] rgbSalt, CspParameters cspParams) : 
            this (strPassword, rgbSalt, "SHA1", 100, cspParams) {}
 
        public PasswordDeriveBytes (byte[] password, byte[] salt, CspParameters cspParams) :
            this (password, salt, "SHA1", 100, cspParams) {}

        public PasswordDeriveBytes (string strPassword, byte[] rgbSalt, String strHashName, int iterations, CspParameters cspParams) : 
            this ((new UTF8Encoding(false)).GetBytes(strPassword), rgbSalt, strHashName, iterations, cspParams) {}
 
        public PasswordDeriveBytes (byte[] password, byte[] salt, String hashName, int iterations, CspParameters cspParams) { 
            this.IterationCount = iterations;
            this.Salt = salt; 
            this.HashName = hashName;
            _password = password;
            _cspParams = cspParams;
        } 

        // 
        // public properties 
        //
 
        public String HashName {
            get { return _hashName; }
            set {
                if (_baseValue != null) 
                    throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_PasswordDerivedBytes_ValuesFixed"), "HashName"));
                _hashName = value; 
                _hash = (HashAlgorithm) CryptoConfig.CreateFromName(_hashName); 
            }
        } 

        public int IterationCount {
            get { return _iterations; }
            set { 
                if (_baseValue != null)
                    throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_PasswordDerivedBytes_ValuesFixed"), "IterationCount")); 
                if (value <= 0) 
                    throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
                _iterations = value; 
            }
        }

        public byte[] Salt { 
            get {
                if (_salt == null) 
                    return null; 
                return (byte[]) _salt.Clone();
            } 
            set {
                if (_baseValue != null)
                    throw new CryptographicException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Cryptography_PasswordDerivedBytes_ValuesFixed"), "Salt"));
                if (value == null) 
                    _salt = null;
                else 
                    _salt = (byte[]) value.Clone(); 
            }
        } 

        //
        // public methods
        // 

        [Obsolete("Rfc2898DeriveBytes replaces PasswordDeriveBytes for deriving key material from a password and is preferred in new applications.")] 
        public override byte[] GetBytes(int cb) { 
            int         ib = 0;
            byte[]      rgb; 
            byte[]      rgbOut = new byte[cb];

            if (_baseValue == null) {
                ComputeBaseValue(); 
            }
            else if (_extra != null) { 
                ib = _extra.Length - _extraCount; 
                if (ib >= cb) {
                    Buffer.InternalBlockCopy(_extra, _extraCount, rgbOut, 0, cb); 
                    if (ib > cb)
                        _extraCount += cb;
                    else
                        _extra = null; 

                    return rgbOut; 
                } 
                else {
                    // 
                    // Note: The second parameter should really be _extraCount instead
                    // However, changing this would constitute a breaking change compared
                    // to what has shipped in V1.x.
                    // 

                    Buffer.InternalBlockCopy(_extra, ib, rgbOut, 0, ib); 
                    _extra = null; 
                }
            } 

            rgb = ComputeBytes(cb-ib);
            Buffer.InternalBlockCopy(rgb, 0, rgbOut, ib, cb-ib);
            if (rgb.Length + ib > cb) { 
                _extra = rgb;
                _extraCount = cb-ib; 
            } 
            return rgbOut;
        } 

        public override void Reset() {
            _prefix = 0;
            _extra = null; 
            _baseValue = null;
        } 
 
        public byte[] CryptDeriveKey (string algname, string alghashname, int keySize, byte[] rgbIV) {
            if (keySize < 0) 
                throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidKeySize"));

            int algidhash = X509Utils.OidToAlgId(alghashname);
            if (algidhash == 0) 
                throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_InvalidAlgorithm"));
            int algid = X509Utils.OidToAlgId(algname); 
            if (algid == 0) 
                throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_InvalidAlgorithm"));
 
            // Validate the rgbIV array
            if (rgbIV == null)
                throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_InvalidIV"));
            return Utils._CryptDeriveKey(ProvHandle, algid, algidhash, _password, keySize << 16, rgbIV); 
        }
 
        // 
        // private methods
        // 

        private byte[] ComputeBaseValue() {
            _hash.Initialize();
            _hash.TransformBlock(_password, 0, _password.Length, _password, 0); 
            if (_salt != null)
                _hash.TransformBlock(_salt, 0, _salt.Length, _salt, 0); 
            _hash.TransformFinalBlock(new byte[0], 0, 0); 
            _baseValue = _hash.Hash;
            _hash.Initialize(); 

            for (int i=1; i<(_iterations-1); i++) {
                _hash.ComputeHash(_baseValue);
                _baseValue = _hash.Hash; 
            }
            return _baseValue; 
        } 

        private byte[] ComputeBytes(int cb) { 
            int                 cbHash;
            int                 ib = 0;
            byte[]              rgb;
 
            _hash.Initialize();
            cbHash = _hash.HashSize / 8; 
            rgb = new byte[((cb+cbHash-1)/cbHash)*cbHash]; 

            CryptoStream cs = new CryptoStream(Stream.Null, _hash, CryptoStreamMode.Write); 
            HashPrefix(cs);
            cs.Write(_baseValue, 0, _baseValue.Length);
            cs.Close();
            Buffer.InternalBlockCopy(_hash.Hash, 0, rgb, ib, cbHash); 
            ib += cbHash;
 
            while (cb > ib) { 
                _hash.Initialize();
                cs = new CryptoStream(Stream.Null, _hash, CryptoStreamMode.Write); 
                HashPrefix(cs);
                cs.Write(_baseValue, 0, _baseValue.Length);
                cs.Close();
                Buffer.InternalBlockCopy(_hash.Hash, 0, rgb, ib, cbHash); 
                ib += cbHash;
            } 
 
            return rgb;
        } 

        void HashPrefix(CryptoStream cs) {
            int    cb = 0;
            byte[] rgb = {(byte)'0', (byte)'0', (byte)'0'}; 

            if (_prefix > 999) 
                    throw new CryptographicException(Environment.GetResourceString("Cryptography_PasswordDerivedBytes_TooManyBytes")); 

            if (_prefix >= 100) { 
                rgb[0] += (byte) (_prefix /100);
                cb += 1;
            }
            if (_prefix >= 10) { 
                rgb[cb] += (byte) ((_prefix % 100) / 10);
                cb += 1; 
            } 
            if (_prefix > 0) {
                rgb[cb] += (byte) (_prefix % 10); 
                cb += 1;
                cs.Write(rgb, 0, cb);
            }
            _prefix += 1; 
        }
    } 
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• OleDbStruct.cs
• DesignerForm.cs
• EditorBrowsableAttribute.cs
• UnauthorizedWebPart.cs
• DataColumn.cs
• AuthenticatingEventArgs.cs
• HashStream.cs
• TemplateControlParser.cs
• LZCodec.cs
• M3DUtil.cs
• ClientCredentialsElement.cs
• Invariant.cs
• ExtendedPropertyCollection.cs
• ISessionStateStore.cs
• ProcessStartInfo.cs
• ActionItem.cs
• SqlDataSourceFilteringEventArgs.cs
• ColorTransform.cs
• FixedSOMSemanticBox.cs
• TextTreeUndo.cs
• WebPartMovingEventArgs.cs
• TextElementAutomationPeer.cs
• LineServices.cs
• DocumentApplicationState.cs
• InfoCardTraceRecord.cs
• sqlnorm.cs
• Trace.cs
• EntityWithChangeTrackerStrategy.cs
• Matrix.cs
• ResourceCategoryAttribute.cs
• TransferRequestHandler.cs
• DrawListViewSubItemEventArgs.cs
• TimeSpanValidatorAttribute.cs
• InvokePattern.cs
• Delegate.cs
• OutKeywords.cs
• ExtendedPropertyDescriptor.cs
• DictionaryItemsCollection.cs
• RuleConditionDialog.cs
• SectionInput.cs
• XmlDocumentType.cs
• AmbientValueAttribute.cs
• CompositeDataBoundControl.cs
• MediaTimeline.cs
• IntSecurity.cs
• SubMenuStyleCollection.cs
• SimpleBitVector32.cs
• TraceUtils.cs
• RIPEMD160Managed.cs
• RecognitionResult.cs
• StringUtil.cs
• CodeExpressionCollection.cs
• ImageBrush.cs
• ComEventsSink.cs
• QueryOperatorEnumerator.cs
• InstanceStoreQueryResult.cs
• _LoggingObject.cs
• TextWriterTraceListener.cs
• OdbcConnectionOpen.cs
• ISCIIEncoding.cs
• OracleCommand.cs
• BinaryFormatterWriter.cs
• ApplicationInterop.cs
• JavascriptXmlWriterWrapper.cs
• WinInet.cs
• StorageBasedPackageProperties.cs
• TextChange.cs
• GeneralTransform3DTo2D.cs
• UnmanagedBitmapWrapper.cs
• EventMappingSettings.cs
• OlePropertyStructs.cs
• DataGridViewColumnTypeEditor.cs
• COM2ICategorizePropertiesHandler.cs
• XDeferredAxisSource.cs
• PermissionToken.cs
• DataGridViewColumnDividerDoubleClickEventArgs.cs
• TypeDependencyAttribute.cs
• PageStatePersister.cs
• DateTime.cs
• ReferenceConverter.cs
• PropertyEmitterBase.cs
• DockProviderWrapper.cs
• DbConnectionPoolCounters.cs
• VirtualDirectoryMappingCollection.cs
• DataSourceView.cs
• Vector.cs
• ToolboxItemCollection.cs
• GroupDescription.cs
• StandardCommandToolStripMenuItem.cs
• TextDecorationCollection.cs
• FaultException.cs
• FileDocument.cs
• LambdaCompiler.Expressions.cs
• BlurBitmapEffect.cs
• DataControlFieldCell.cs
• TextTreeDeleteContentUndoUnit.cs
• WindowsStreamSecurityUpgradeProvider.cs
• ResourcePermissionBaseEntry.cs
• externdll.cs
• FixedSOMPage.cs