Exemple #1
0
        public override bool VerifyHash(byte[] rgbHash, string str, byte[] rgbSignature)
        {
            bool   valid  = true;
            IntPtr prov   = IntPtr.Zero;
            IntPtr hash   = IntPtr.Zero;
            IntPtr rsaKey = IntPtr.Zero;

            try
            {
                byte [] tempHash = (byte [])rgbHash.Clone();
                byte [] tempSig  = (byte [])rgbSignature.Clone();
                prov = Context.AcquireContext("dSaContainerImp", ProvName.MS_ENH_DSS_DH_PROV, ProvType.DSS_DH, ContextFlag.NONE);
                hash = GetHashAlgorithm(prov, str);
                //Hash.HashData(hash, tempData);
                Hash.SetHashParam(hash, HashParam.HASHVAL, tempHash);
                rsaKey = Key.ImportKey(prov, _dsa.rawKey, IntPtr.Zero, GenKeyParam.NONE); //EXPORTABLE wont work here
                Array.Reverse(tempSig, 0, 20);                                            //r
                Array.Reverse(tempSig, 20, 20);                                           //s
                Hash.VerifySignature(hash, tempSig, rsaKey);
            }
            catch (Exception)
            {
                valid = false;
            }
            finally
            {
                Key.DestroyKey(rsaKey);
                Hash.DestroyHash(hash);
                Context.ReleaseContext(prov);
            }
            return(valid);
        }
Exemple #2
0
        public DSACryptoServiceProvider(bool genKey)
        {
            IntPtr prov = IntPtr.Zero;
            IntPtr key  = IntPtr.Zero;

            //for bad key state
            //Crypto.CryptAcquireContext(out prov, "dSaContainer", ProvName.MS_ENH_DSS_DH_PROV, (uint)ProvType.DSS_DH, (uint)ContextFlag.DELETEKEYSET);
            //Crypto.CryptAcquireContext(out prov, "dSaContainer", ProvName.MS_ENH_DSS_DH_PROV, (uint)ProvType.DSS_DH, (uint)ContextFlag.NEWKEYSET);
            try
            {
                if (genKey == false)                //faster
                {
                    prov = Context.AcquireContext("dSaContainer", ProvName.MS_ENH_DSS_DH_PROV, ProvType.DSS_DH, ContextFlag.NONE);
                    key  = Key.GetUserKey(prov, KeySpec.SIGNATURE);
                }
                else                 //create new one
                {
                    prov = Context.AcquireContext("dSaContainerImp", ProvName.MS_ENH_DSS_DH_PROV, ProvType.DSS_DH, ContextFlag.NONE);
                    key  = Key.GenKey(prov, Calg.DSS_SIGN, GenKeyParam.EXPORTABLE);
                }
                byte [] baPriKey = Key.ExportKey(key, IntPtr.Zero, KeyBlob.PRIVATEKEYBLOB);
                byte [] baPubKey = Key.ExportKey(key, IntPtr.Zero, KeyBlob.PUBLICKEYBLOB);
                _dsa = new Dsa(baPriKey);                 //X is returned
                Dsa dsaPub = new Dsa(baPubKey);           //Y is only from public call
                _dsa.Y = (byte[])dsaPub.Y.Clone();
            }
            finally
            {
                Key.DestroyKey(key);
                Context.ReleaseContext(prov);
            }
        }
        public RSACryptoServiceProvider(KeySpec keySpec, bool genKey)
        {
            IntPtr prov   = IntPtr.Zero;
            IntPtr rsaKey = IntPtr.Zero;

            try
            {
                this.keySpec = keySpec;
                if (genKey == false)                //faster
                {
                    prov   = Context.AcquireContext("rSaContainer");
                    rsaKey = Key.GetUserKey(prov, keySpec);
                }
                else                 //new key
                {
                    prov = Context.AcquireContext("rSaContainerImp");
                    Calg calg = Calg.RSA_KEYX;
                    if (keySpec == KeySpec.SIGNATURE)
                    {
                        calg = Calg.RSA_SIGN;
                    }
                    rsaKey = Key.GenKey(prov, calg, GenKeyParam.EXPORTABLE);
                }
                byte [] baPrivKey = Key.ExportKey(rsaKey, IntPtr.Zero, KeyBlob.PRIVATEKEYBLOB);
                _rsa = new Rsa(baPrivKey);
            }
            finally
            {
                Key.DestroyKey(rsaKey);
                Context.ReleaseContext(prov);
            }
        }
Exemple #4
0
        public override byte[] SignHash(byte[] rgbHash, string str)
        {
            IntPtr prov   = IntPtr.Zero;
            IntPtr hash   = IntPtr.Zero;
            IntPtr rsaKey = IntPtr.Zero;

            byte [] sig;
            try
            {
                byte [] tempHash = (byte[])rgbHash.Clone();
                prov = Context.AcquireContext("dSaContainerImp", ProvName.MS_ENH_DSS_DH_PROV, ProvType.DSS_DH, ContextFlag.NONE);
                hash = GetHashAlgorithm(prov, str);
                //Hash.HashData(hash, tempData);
                Hash.SetHashParam(hash, HashParam.HASHVAL, tempHash);
                rsaKey = Key.ImportKey(prov, _dsa.rawKey, IntPtr.Zero, GenKeyParam.EXPORTABLE);
                sig    = Hash.SignHash(hash, KeySpec.SIGNATURE);
                Array.Reverse(sig, 0, 20);                 //r
                Array.Reverse(sig, 20, 20);                //s
            }
            finally
            {
                Key.DestroyKey(rsaKey);
                Hash.DestroyHash(hash);
                Context.ReleaseContext(prov);
            }
            return(sig);
        }
        public override bool VerifyHash(byte[] rgbHash, string str, byte[] rgbSignature)
        {
            bool   valid  = true;
            IntPtr prov   = IntPtr.Zero;
            IntPtr hash   = IntPtr.Zero;
            IntPtr rsaKey = IntPtr.Zero;

            try
            {
                byte [] tempHash = (byte [])rgbHash.Clone();
                byte [] tempSig  = (byte [])rgbSignature.Clone();
                prov = Context.AcquireContext("rSaContainerImp");
                hash = GetHashAlgorithm(prov, str);
                //Hash.HashData(hash, tempData);
                Hash.SetHashParam(hash, HashParam.HASHVAL, tempHash);
                rsaKey = Key.ImportKey(prov, _rsa.rawKey, IntPtr.Zero, GenKeyParam.NONE);                 //EXPORTABLE
                Array.Reverse(tempSig, 0, tempSig.Length);
                Hash.VerifySignature(hash, tempSig, rsaKey);
            }
            catch (Exception ex)
            {
                string sex = ex.ToString();
                valid = false;
            }
            finally
            {
                Key.DestroyKey(rsaKey);
                Hash.DestroyHash(hash);
                Context.ReleaseContext(prov);
            }
            return(valid);
        }
        public override byte[] SignHash(byte[] rgbHash, string str)
        {
            IntPtr prov   = IntPtr.Zero;
            IntPtr hash   = IntPtr.Zero;
            IntPtr rsaKey = IntPtr.Zero;

            byte [] sig;
            try
            {
                byte [] tempHash = (byte[])rgbHash.Clone();
                prov = Context.AcquireContext("rSaContainerImp");
                hash = GetHashAlgorithm(prov, str);
                //Hash.HashData(hash, tempData);
                Hash.SetHashParam(hash, HashParam.HASHVAL, tempHash);
                rsaKey = Key.ImportKey(prov, _rsa.rawKey, IntPtr.Zero, GenKeyParam.EXPORTABLE);
                sig    = Hash.SignHash(hash, keySpec);              //KeySpec.EXCHANGE?
                Array.Reverse(sig, 0, sig.Length);
            }
            finally
            {
                Key.DestroyKey(rsaKey);
                Hash.DestroyHash(hash);
                Context.ReleaseContext(prov);
            }
            return(sig);
        }
        public MACTripleDES()
        {
            IntPtr prov  = Context.AcquireContext();
            IntPtr ipKey = OpenNETCF.Security.Cryptography.Internal.Key.GenKey(prov, Calg.TRIP_DES, GenKeyParam.EXPORTABLE);

            key = OpenNETCF.Security.Cryptography.Internal.Key.ExportSessionKey(prov, ipKey, 24, true);
            //reversed above
            OpenNETCF.Security.Cryptography.Internal.Key.DestroyKey(ipKey);
            OpenNETCF.Security.Cryptography.Internal.Context.ReleaseContext(prov);
        }
Exemple #8
0
        public TripleDESCryptoServiceProvider()
        {
            IntPtr prov  = IntPtr.Zero;
            IntPtr ipKey = IntPtr.Zero;

            try
            {
                prov     = Context.AcquireContext("sYmContainer");
                ipKey    = OpenNETCF.Security.Cryptography.NativeMethods.Key.GenKey(prov, Calg.TRIP_DES, GenKeyParam.EXPORTABLE);
                this.Key = OpenNETCF.Security.Cryptography.NativeMethods.Key.ExportSessionKey(prov, ipKey, 24, true);
                this.IV  = OpenNETCF.Security.Cryptography.NativeMethods.Key.GetIv(ipKey);
            }
            finally
            {
                OpenNETCF.Security.Cryptography.NativeMethods.Key.DestroyKey(ipKey);
                Context.ReleaseContext(prov);
            }
        }
Exemple #9
0
        //non-standard
        public override byte[] EncryptValue(byte[] pBuff)
        {
            IntPtr prov  = IntPtr.Zero;
            IntPtr ipKey = IntPtr.Zero;

            byte [] cBuff;
            try
            {
                prov  = Context.AcquireContext("sYmContainer");
                ipKey = OpenNETCF.Security.Cryptography.NativeMethods.Key.ImportSessionKey(prov, OpenNETCF.Security.Cryptography.NativeMethods.Calg.TRIP_DES, this.Key, true);
                OpenNETCF.Security.Cryptography.NativeMethods.Key.SetIv(ipKey, this.IV);
                cBuff = OpenNETCF.Security.Cryptography.NativeMethods.Cipher.Encrypt(ipKey, IntPtr.Zero, pBuff);
            }
            finally
            {
                OpenNETCF.Security.Cryptography.NativeMethods.Key.DestroyKey(ipKey);
                Context.ReleaseContext(prov);
            }
            return(cBuff);
        }
        //non-standard
        public override byte[] DecryptValue(byte[] cBuff)
        {
            IntPtr prov  = IntPtr.Zero;
            IntPtr ipKey = IntPtr.Zero;

            byte [] pBuff;
            try
            {
                prov  = Context.AcquireContext("sYmContainer");
                ipKey = OpenNETCF.Security.Cryptography.Internal.Key.ImportSessionKey(prov, Calg.DES, this.Key, true);
                OpenNETCF.Security.Cryptography.Internal.Key.SetIv(ipKey, this.IV);
                pBuff = Cipher.Decrypt(ipKey, IntPtr.Zero, cBuff);
            }
            finally
            {
                OpenNETCF.Security.Cryptography.Internal.Key.DestroyKey(ipKey);
                Context.ReleaseContext(prov);
            }
            return(pBuff);
        }
        public override byte[] DecryptValue(byte[] cBuff)
        {
            IntPtr prov   = IntPtr.Zero;
            IntPtr rsaKey = IntPtr.Zero;

            byte [] pBuff;
            try
            {
                prov   = Context.AcquireContext("rSaContainerImp");
                rsaKey = Key.ImportKey(prov, _rsa.rawKey, IntPtr.Zero, GenKeyParam.EXPORTABLE);
                byte [] tempBuff = (byte [])cBuff.Clone();
                Array.Reverse(tempBuff, 0, tempBuff.Length);
                pBuff = Cipher.Decrypt(rsaKey, IntPtr.Zero, tempBuff);
            }
            finally
            {
                Key.DestroyKey(rsaKey);
                Context.ReleaseContext(prov);
            }
            return(pBuff);
        }
        /// <summary>
        /// Derives a cryptographic key from the PasswordDeriveBytes object.
        /// </summary>
        /// <remarks>
        /// If the keySize parameter is set to 0, the default key size for the specified algorithm is used.
        /// </remarks>
        /// <param name="algName">The algorithm name for which to derive the key. </param>
        /// <param name="algHashName">The hash algorithm name to use to derive the key. </param>
        /// <param name="keySize">The size of the key to derive. </param>
        /// <param name="IV">The initialization vector (IV) to use to derive the key.</param>
        /// <returns>The derived key.</returns>
        public byte [] CryptDeriveKey(string algName, string algHashName, int keySize, byte [] IV)
        {
            //RC2 / SHA1 works
            //TODO DES / MD5 seems to be salted
            //TODO not using salt, IV, or keySize
            IntPtr prov = Context.AcquireContext();

            byte [] baPassword = Format.GetBytes(this.password);
            IntPtr  hash       = GetHashAlgorithm(prov, algHashName);

            Hash.HashData(hash, baPassword);

            IntPtr key    = GetKeyAlgorithm(prov, hash, algName);
            int    keyLen = Key.GetKeyLength(key) / 8;

            byte [] baKey = Key.ExportSessionKey(prov, key, keyLen, true);

            Hash.DestroyHash(hash);
            Key.DestroyKey(key);

            Context.ReleaseContext(prov);
            return(baKey);
        }