예제 #1
0
        /// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
        /// <param name="cryptProvider">Tipo de criptografia.</param>

        public Criptografia(CryptProvider cryptProvider)
        {
            // Seleciona algoritmo simétrico
            switch (cryptProvider)
            {
            case CryptProvider.Rijndael:
                _algorithm     = new RijndaelManaged();
                _cryptProvider = CryptProvider.Rijndael;
                break;

            case CryptProvider.RC2:
                _algorithm     = new RC2CryptoServiceProvider();
                _cryptProvider = CryptProvider.RC2;
                break;

            case CryptProvider.DES:
                _algorithm     = new DESCryptoServiceProvider();
                _cryptProvider = CryptProvider.DES;
                break;

            case CryptProvider.TripleDES:
                _algorithm     = new TripleDESCryptoServiceProvider();
                _cryptProvider = CryptProvider.TripleDES;
                break;
            }
            _algorithm.Mode = CipherMode.CBC;
        }
예제 #2
0
 /// <summary>
 /// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
 /// </summary>
 public Criptografia()
 {
     _algorithm = new RijndaelManaged();
     _algorithm.Mode = CipherMode.CBC;
     _cryptProvider = CryptProvider.Rijndael;
     _key = "KPT873KL23DF90WI5E1JAS467NMCXXL6JAOAUWLTQNTAOMM4A492EQ3KHJUI2347EJHJKDF3424SKLCK3LAKDJSL9RTIKJ";
 }
        /// <summary>
        /// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
        /// </summary>
        /// <param name="cryptProvider">Tipo de criptografia.</param>
        public CryptService(CryptProvider cryptProvider)
        {
            // Seleciona algoritmo simétrico
            switch (cryptProvider)
            {
                case CryptProvider.Rijndael:
                    algoritmo = new RijndaelManaged();
                    provider = CryptProvider.Rijndael;
                    break;

                case CryptProvider.RC2:
                    algoritmo = new RC2CryptoServiceProvider();
                    provider = CryptProvider.RC2;
                    break;

                case CryptProvider.DES:
                    algoritmo = new DESCryptoServiceProvider();
                    provider = CryptProvider.DES;
                    break;

                case CryptProvider.TripleDES:
                    algoritmo = new TripleDESCryptoServiceProvider();
                    provider = CryptProvider.TripleDES;
                    break;
            }
            algoritmo.Mode = CipherMode.CBC;
        }
 /// <summary>
 /// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
 /// </summary>
 public CriptografiaServices()
 {
     _algorithm      = new RijndaelManaged();
     _algorithm.Mode = CipherMode.CBC;
     _cryptProvider  = CryptProvider.Rijndael;
     _key            = RegistroLocalService.BuscarChaveServico();
 }
예제 #5
0
    /// <summary>
    ///     Construtor com o tipo de criptografia a ser usada.
    /// </summary>
    /// <param name="cryptProvider">Tipo de criptografia.</param>
    /// <param name="ChaveSimetrica">Chave para critografar o arquivo.</param>
    /// <param name="FilePath">Caminho completo do arquivo a ser encriptado.</param>
    /// <param name="Descriptografar">Quando setado como true, informa à classe que não é para
    /// criptografar o arquivo, e sim descriptografá-lo.</param>
    public SkaEncrypt(CryptProvider cryptProvider, String ChaveSimetrica, String FilePath, Boolean Descriptografar = false)
    {
        // Seleciona algoritmo simétrico
        switch (cryptProvider)
        {
        case CryptProvider.Rijndael:
            _algorithm     = new RijndaelManaged();
            _cryptProvider = CryptProvider.Rijndael;
            break;

        case CryptProvider.RC2:
            _algorithm     = new RC2CryptoServiceProvider();
            _cryptProvider = CryptProvider.RC2;
            break;

        case CryptProvider.DES:
            _algorithm     = new DESCryptoServiceProvider();
            _cryptProvider = CryptProvider.DES;
            break;

        case CryptProvider.TripleDES:
            _algorithm     = new TripleDESCryptoServiceProvider();
            _cryptProvider = CryptProvider.TripleDES;
            break;
        }
        _algorithm.Mode = CipherMode.CBC;
        _key            = ChaveSimetrica;
        _filePath       = FilePath;

        if (!Descriptografar)
        {
            EncriptarArquivo();
        }
    }
예제 #6
0
 /// <summary>
 /// Contrutor padrão da classe, é setado um tipo de criptografia padrão.
 /// </summary>
 public Criptografia(string key)
 {
     _algorithm      = new RijndaelManaged();
     _algorithm.Mode = CipherMode.CBC;
     _cryptProvider  = CryptProvider.Rijndael;
     this._key       = key.ToString();// ConfigurationManager.AppSettings["CriptoKey"].ToString();//.Substring(0, 8);
 }
예제 #7
0
        /// <summary>
        /// Construtor com o tipo de criptografia a ser usada.
        /// </summary>
        /// <param name="cryptProvider">Tipo de criptografia.</param>
        public Criptografia(CryptProvider cryptProvider, string key)
        {
            // Seleciona algoritmo simétrico
            //this._key = ConfigurationManager.AppSettings["CriptoKey"].ToString();//.Substring(0, 8);
            this._key = key.ToString();
            switch (cryptProvider)
            {
            case CryptProvider.Rijndael:
                _algorithm     = new RijndaelManaged();
                _cryptProvider = CryptProvider.Rijndael;
                break;

            case CryptProvider.RC2:
                _algorithm     = new RC2CryptoServiceProvider();
                _cryptProvider = CryptProvider.RC2;
                break;

            case CryptProvider.DES:
                _algorithm     = new DESCryptoServiceProvider();
                _cryptProvider = CryptProvider.DES;
                break;

            case CryptProvider.TripleDES:
                _algorithm     = new TripleDESCryptoServiceProvider();
                _cryptProvider = CryptProvider.TripleDES;
                break;
            }
            _algorithm.Mode = CipherMode.CBC;
        }
예제 #8
0
    /// <summary>
    ///     Construtor com o tipo de criptografia a ser usada.
    /// </summary>
    /// <param name="cryptProvider">Tipo de criptografia.</param>
    /// <param name="ChaveSimetrica">Chave para critografar o arquivo.</param>
    /// <param name="FilePath">Caminho completo do arquivo a ser encriptado.</param>
    /// <param name="Descriptografar">Quando setado como true, informa à classe que não é para
    /// criptografar o arquivo, e sim descriptografá-lo.</param>
    public CustomEncrypt(CryptProvider cryptProvider, String ChaveSimetrica, String FilePath, Boolean Descriptografar = false)
    {
        // Seleciona algoritmo simétrico
        switch (cryptProvider)
        {
        case CryptProvider.Rijndael:
            mAlgorithm     = new RijndaelManaged();
            mCryptProvider = CryptProvider.Rijndael;
            break;

        case CryptProvider.RC2:
            mAlgorithm     = new RC2CryptoServiceProvider();
            mCryptProvider = CryptProvider.RC2;
            break;

        case CryptProvider.DES:
            mAlgorithm     = new DESCryptoServiceProvider();
            mCryptProvider = CryptProvider.DES;
            break;

        case CryptProvider.TripleDES:
            mAlgorithm     = new TripleDESCryptoServiceProvider();
            mCryptProvider = CryptProvider.TripleDES;
            break;
        }
        mAlgorithm.Mode = CipherMode.CBC;
        mKey            = ChaveSimetrica;
        mFilePath       = FilePath;

        if (!Descriptografar)
        {
            EncryptFile();
        }
    }
예제 #9
0
        /// <summary>
        /// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
        /// </summary>

        public HelperCrypt()
        {
            _algorithm = new RijndaelManaged {
                Mode = CipherMode.CBC
            };
            _cryptProvider = CryptProvider.Rijndael;
        }
예제 #10
0
    /// <summary>
    ///     Construtor utilizando apenas para criptografar textos (sem arquivos físicos).
    /// </summary>
    /// <param name="cryptProvider">Tipo de criptografia.</param>
    /// <param name="ChaveSimetrica">Chave para critografar o arquivo.</param>
    public CustomEncrypt(CryptProvider cryptProvider, String ChaveSimetrica)
    {
        // Seleciona algoritmo simétrico
        switch (cryptProvider)
        {
        case CryptProvider.Rijndael:
            mAlgorithm     = new RijndaelManaged();
            mCryptProvider = CryptProvider.Rijndael;
            break;

        case CryptProvider.RC2:
            mAlgorithm     = new RC2CryptoServiceProvider();
            mCryptProvider = CryptProvider.RC2;
            break;

        case CryptProvider.DES:
            mAlgorithm     = new DESCryptoServiceProvider();
            mCryptProvider = CryptProvider.DES;
            break;

        case CryptProvider.TripleDES:
            mAlgorithm     = new TripleDESCryptoServiceProvider();
            mCryptProvider = CryptProvider.TripleDES;
            break;
        }
        mAlgorithm.Mode = CipherMode.CBC;
        mKey            = ChaveSimetrica;
        mFilePath       = "";
    }
예제 #11
0
        public CryptHelpers(CryptProvider cryptProvider = CryptProvider.Rijndael)
        {
            switch (cryptProvider)
            {
            case CryptProvider.Rijndael:
                _algorithm     = new RijndaelManaged();
                _cryptProvider = CryptProvider.Rijndael;
                break;

            case CryptProvider.RC2:
                _algorithm     = new RC2CryptoServiceProvider();
                _cryptProvider = CryptProvider.RC2;
                break;

            case CryptProvider.DES:
                _algorithm     = new DESCryptoServiceProvider();
                _cryptProvider = CryptProvider.DES;
                break;

            case CryptProvider.TripleDES:
                _algorithm     = new TripleDESCryptoServiceProvider();
                _cryptProvider = CryptProvider.TripleDES;
                break;
            }
            _algorithm.Mode = CipherMode.CBC;
        }
예제 #12
0
        public Cryptography(CryptProvider provider, String key)
        {
            this.Provider = provider;

            switch (provider)
            {
            case CryptProvider.DES:
                break;

            case CryptProvider.RC2:
                break;

            case CryptProvider.TripleDES:
                break;

            case CryptProvider.MD5:
                break;

            case CryptProvider.Rijndael:
                this.Algorithm      = new RijndaelManaged();
                this.Algorithm.Mode = CipherMode.CBC;
                this.Algorithm.IV   = new byte[] { 0xf, 0x6f, 0x13, 0x2e, 0x35, 0xc2, 0xcd, 0xf9, 0x5, 0x46, 0x9c, 0xea, 0xa8, 0x4b, 0x73, 0xcc };
                break;
            }

            this.Key           = GetKey(key);
            this.Algorithm.Key = this.Key;
        }
예제 #13
0
        /// <summary>
        /// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
        /// </summary>
        /// <param name="cryptProvider">Tipo de criptografia.</param>
        public Cryptography( CryptProvider cryptProvider )
        {
            // Seleciona algoritmo simétrico
            switch ( cryptProvider )
            {
                case CryptProvider.Rijndael:
                    _algorithm = new RijndaelManaged ( );
                    _cryptProvider = CryptProvider.Rijndael;
                    break;
                case CryptProvider.RC2:
                    _algorithm = new RC2CryptoServiceProvider ( );
                    _cryptProvider = CryptProvider.RC2;
                    break;
                case CryptProvider.DES:
                    _algorithm = new DESCryptoServiceProvider ( );
                    _cryptProvider = CryptProvider.DES;
                    break;
                case CryptProvider.TripleDES:
                    _algorithm = new TripleDESCryptoServiceProvider ( );
                    _cryptProvider = CryptProvider.TripleDES;
                    break;
            }

            _algorithm.Mode = CipherMode.CBC;
        }
예제 #14
0
 /// <summary> Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael). </summary>
 public Cripto(string key)
 {
     _algorithm      = new RijndaelManaged();
     _algorithm.Mode = CipherMode.CBC;
     _cryptProvider  = CryptProvider.Rijndael;
     _key            = key;
 }
예제 #15
0
 /// <summary>
 /// Contrutor padrão da classe, é setado um tipo de criptografia padrão.
 /// </summary>
 public Crypt()
 {
     _algorithm      = new RijndaelManaged();
     _algorithm.Mode = CipherMode.CBC;
     _cryptProvider  = CryptProvider.Rijndael;
     Key             = "WebEleitor1234/";
 }
예제 #16
0
        /// <summary>
        /// Construtor com o tipo de criptografia a ser usada.
        /// </summary>
        /// <param name="cryptProvider">Tipo de criptografia.</param>
        public Crypt(CryptProvider cryptProvider)
        {
            // Seleciona algoritmo simétrico

            /*switch (cryptProvider) - MÃO DE FERNANDO PASSAIA AQUI, GAMBIARRA
             *
             *      case CryptProvider.Rijndael:
             *
             *      break;
             *  case CryptProvider.RC2:
             *      _algorithm = new RC2CryptoServiceProvider();
             *      _cryptProvider = CryptProvider.RC2;
             *      break;
             *  case CryptProvider.DES:
             *      _algorithm = new DESCryptoServiceProvider();
             *      _cryptProvider = CryptProvider.DES;
             *      break;
             *  case CryptProvider.TripleDES:
             *      _algorithm = new TripleDESCryptoServiceProvider();
             *      _cryptProvider = CryptProvider.TripleDES;
             *      break;
             * }*/

            _algorithm      = new RijndaelManaged();
            _cryptProvider  = CryptProvider.Rijndael;
            _algorithm.Mode = CipherMode.CBC;
        }
        /// <summary>
        /// Construtor com o tipo de criptografia a ser usada Você pode escolher o tipo pelo Enum chamado CryptProvider.
        /// </summary>
        /// <param name="cryptProvider">Tipo de criptografia.</param>
        public CryptService(CryptProvider cryptProvider)
        {
            // Seleciona algoritmo simétrico
            switch (cryptProvider)
            {
            case CryptProvider.Rijndael:
                algoritmo = new RijndaelManaged();
                provider  = CryptProvider.Rijndael;
                break;

            case CryptProvider.RC2:
                algoritmo = new RC2CryptoServiceProvider();
                provider  = CryptProvider.RC2;
                break;

            case CryptProvider.DES:
                algoritmo = new DESCryptoServiceProvider();
                provider  = CryptProvider.DES;
                break;

            case CryptProvider.TripleDES:
                algoritmo = new TripleDESCryptoServiceProvider();
                provider  = CryptProvider.TripleDES;
                break;
            }
            algoritmo.Mode = CipherMode.CBC;
        }
예제 #18
0
파일: Criptografia.cs 프로젝트: TCCFW/TCC
        /// <summary>
        /// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
        /// </summary>
        public Criptografia()
        {
            _algorithm = new RijndaelManaged();

            _algorithm.Mode = CipherMode.CBC;

            _cryptProvider = CryptProvider.Rijndael;
        }
예제 #19
0
        /// <summary>

        /// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).

        /// </summary>

        public Criptografia()
        {
            _algorithm = new RijndaelManaged();

            _algorithm.Mode = CipherMode.CBC;

            _cryptProvider = CryptProvider.Rijndael;
        }
예제 #20
0
        private void checkedChanged(object sender, EventArgs e)
        {
            var rb    = (RadioButton)sender;
            var index = int.Parse(rb.Tag.ToString());

            if (rb.Checked)
            {
                providerSelecionado = (CryptProvider)index;
            }
        }
예제 #21
0
        public string Authenticate(string userName, string password)
        {
            var account = AccountRepository.Get(userName);

            if (account != null)
            {
                if (account.ValidatePassword(CryptProvider, password))
                {
                    return(CryptProvider.Encrypt(account.CreateToken().GenerateString(DateProvider)));
                }
            }
            return(string.Empty);
        }
예제 #22
0
        private static void Constructor()
        {
            if (_algorithm == null)
            {
                _algorithm      = new RijndaelManaged();
                _algorithm.Mode = CipherMode.CBC;
            }

            if (_cryptProvider == CryptProvider.None)
            {
                _cryptProvider = CryptProvider.Rijndael;
            }
        }
예제 #23
0
 public xml_request(string DecryptKey, string string_request)
 {
     try
     {
         _isvalid = false;
         // xâu rỗng đưa vào
         if (String.IsNullOrEmpty(string_request))
         {
             return;
         }
         CryptProvider myde = new CryptProvider();
         // giải mã xâu
         source = myde.Decrypt(DecryptKey, string_request);
         // chuyển thành các đối tượng
         doc.LoadXml(source.Trim());
         _isvalid = true;
     }
     catch (Exception ex)
     { throw ex; }
 }
예제 #24
0
 public Token Validate(string token)
 {
     return(new TokenParser(CryptProvider.Decrypt(token)).GetToken());
 }
        // ----------------------------------------------------------------------------------------------------

        #region Constructors

        /// <summary>Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).</summary>
        public CryptService()
        {
            algoritmo      = new RijndaelManaged();
            algoritmo.Mode = CipherMode.CBC;
            provider       = CryptProvider.Rijndael;
        }
예제 #26
0
		public static bool CryptAcquireContext(ref IntPtr hProv, string pszContainer, string pszProvider,
																						CryptProvider prov, ContextFlags flags)
			=> CryptAcquireContext(ref hProv, pszContainer, pszProvider, (uint) prov, (uint) flags);
예제 #27
0
 /// <summary>
 /// Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).
 /// </summary>
 public Encryptar()
 {
     _algorithm      = new RijndaelManaged();
     _algorithm.Mode = CipherMode.CBC;
     _cryptProvider  = CryptProvider.Rijndael;
 }
예제 #28
0
        public string response_string(string key)
        {
            CryptProvider myen = new CryptProvider();

            return(myen.Encrypt(key, response_string()));
        }
예제 #29
0
 public User()
 {
     myCrypt = new CryptProvider();
 }
        // ----------------------------------------------------------------------------------------------------

        #region Constructors

        /// <summary>Contrutor padrão da classe, é setado um tipo de criptografia padrão (Rijndael).</summary>
        public CryptService()
        {
            algorithm = new RijndaelManaged();
            algorithm.Mode = CipherMode.CBC;
            provider = CryptProvider.Rijndael;
        }
예제 #31
0
 public Descriptografia NoMetodo(CryptProvider mode)
 {
     this._mode = mode;
     return(this);
 }
예제 #32
0
 /// <summary>
 /// Contrutor padrão da classe, é setado um tipo de criptografia padrão.
 /// </summary>
 public ServicoDeCriptografia()
 {
     algorithm      = new RijndaelManaged();
     algorithm.Mode = CipherMode.CBC;
     cryptProvider  = CryptProvider.Rijndael;
 }