public string Encriptar(Valor llave, Valor palabra, EnumAlgoritmo algoritmo)
        {
            byte[] keyArray;
            byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(palabra.ToString());

            keyArray = UTF8Encoding.UTF8.GetBytes(llave.ToString());

            byte[] resultArray;
            try
            {
                using (SymmetricAlgorithm symmetricAlgorithm = ProveedorAlgoritmo(algoritmo))
                {
                    symmetricAlgorithm.Key = keyArray;
                    symmetricAlgorithm.IV = IV(algoritmo);
                    symmetricAlgorithm.Padding = PaddingMode.Zeros;

                    ICryptoTransform cTransform = symmetricAlgorithm.CreateEncryptor();
                    resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
                }
            }
            catch (Exception e)
            {
                throw e;
            }

            return Convert.ToBase64String(resultArray, 0, resultArray.Length);
        }
        protected override void AgregarCabeceraMensaje(CAMPO_PLANTILLA campoPlantilla, Valor valorCabecera, Valor valorCuerpo)
        {
            EnumTipoDatoCampo tipoDato = (EnumTipoDatoCampo)
            Enum.ToObject(typeof(EnumTipoDatoCampo), campoPlantilla.TIPO_DATO.TDT_CODIGO);

            Campo campo = new Campo(campoPlantilla.CMP_CODIGO, campoPlantilla.CMP_CABECERA, true, campoPlantilla.CMP_POSICION_RELATIVA
                , campoPlantilla.CMP_NOMBRE, false, 0, null, campoPlantilla.CMP_LONGITUD, valorCuerpo, tipoDato, false);

            Campos.Add(campo);
        }
        protected override void AgregarCuerpoMensaje(CAMPO campoMensaje, Valor valorCabecera, Valor valorCuerpo)
        {
            EnumTipoDatoCampo tipoDato = (EnumTipoDatoCampo)
                        Enum.ToObject(typeof(EnumTipoDatoCampo), campoMensaje.TIPO_DATO.TDT_CODIGO);

            Campo campo = new Campo(campoMensaje.CAM_CODIGO, campoMensaje.CAM_CABECERA, campoMensaje.CAM_REQUERIDO, campoMensaje.CAM_POSICION_RELATIVA
                , campoMensaje.CAM_NOMBRE, false, 0, null, campoMensaje.CAM_LONGITUD, valorCuerpo, tipoDato
                , campoMensaje.CAM_TANQUEO.HasValue ? campoMensaje.CAM_TANQUEO.Value : false);

            Campos.Add(campo);
        }
 public Valor Operar(Valor llave1, Valor llave2
     , EnumOperacionLlave operacionLlave)
 {
     switch (operacionLlave)
     {
         case EnumOperacionLlave.Concatenacion:
             return Concatenacion(llave1, llave2);
         case EnumOperacionLlave.XOR:
             return XOR(llave1, llave2);
         default:
             throw new Exception("Error: Operacion - Operar");
     }
 }
        public CriptografiaCampo(Mensaje mensaje, CRIPTOGRAFIA_CAMPO criptografiaCampo)
        {
            this.llave1 = Llave.ValorLlave(mensaje, criptografiaCampo.CRC_LLAVE_1
                , criptografiaCampo.CAMPO_LLAVE_1, criptografiaCampo.CRC_TIPO_LLAVE_1);

            this.segundaLlave = criptografiaCampo.CRC_SEGUNDA_LLAVE;

            if (segundaLlave)
            {
                this.llave2 = Llave.ValorLlave(mensaje, criptografiaCampo.CRC_LLAVE_2
                    , criptografiaCampo.CAMPO_LLAVE_2, criptografiaCampo.CRC_TIPO_LLAVE_2.Value);
                this.operacionLlave = (EnumOperacionLlave)Enum.ToObject(typeof(EnumOperacionLlave), criptografiaCampo.CRC_OPERACION_LLAVE);
            }
            this.algoritmo = (EnumAlgoritmo)Enum.ToObject(typeof(EnumAlgoritmo), criptografiaCampo.CRC_ALGORITMO);
        }
        private Valor XOR(Valor llave1, Valor llave2)
        {
            byte[] llaveArray1 = ASCIIEncoding.ASCII.GetBytes(llave1.ToString());
            byte[] llaveArray2 = ASCIIEncoding.ASCII.GetBytes(llave2.ToString());

            BitArray bitArray1 = new BitArray(llaveArray1);
            BitArray bitArray2 = new BitArray(llaveArray2);

            BitArray bitArrayResultado=bitArray1.Xor(bitArray2);

            byte[] llaveArrayResultado = ToByteArray(bitArrayResultado);

            string resultado = Convert.ToBase64String(llaveArrayResultado, 0, llaveArrayResultado.Length);

            return new Caracter(resultado);
        }
 public Campo(int codigo, bool esCabecera, bool mandatorio, int? posicionRelativa, string nombre, bool variable
     , int? longitudCabecera, Valor valorCabecera, int longitudCuerpo
     , Valor valorCuerpo, EnumTipoDatoCampo tipoDato, bool esTanqueo)
 {
     Codigo = codigo;
     Mandatorio = mandatorio;
     PosicionRelativa = posicionRelativa;
     Nombre = nombre;
     Variable = variable;
     LongitudCabecera = longitudCabecera;
     ValorCabecera = valorCabecera;
     LongitudCuerpo = longitudCuerpo;
     ValorCuerpo = valorCuerpo;
     TipoDato = tipoDato;
     TipoCampo = esCabecera ? TipoCampoMensaje.CabeceraMensaje : TipoCampoMensaje.CuerpoMensaje;
     EsTanqueo = esTanqueo;
 }
 public bool Validar(VALIDACION_CAMPO vcampo, Valor valor)
 {
     bool pasaValidacion;
     switch (vcampo.VLC_INCLUSION_EXCLUSION)
     {
         case (int)EnumCriterioAplicacion.Inclusion:
             pasaValidacion = vcampo.VLC_CONDICION != null ? EvaluarInclusionPorCondicion((int)vcampo.VLC_CONDICION, vcampo.VLC_VALOR, valor) :
                                                             EvaluarInclusionPorTabla(vcampo.TABLA.TBL_NOMBRE, vcampo.COLUMNA.COL_NOMBRE, valor);
             break;
         case (int)EnumCriterioAplicacion.Procedimiento:
             pasaValidacion = EvaluarProcedimiento(vcampo.VLC_PROCEDIMIENTO, valor);
             break;
         case (int)EnumCriterioAplicacion.Componente:
             pasaValidacion = EvaluarComponente(vcampo.VLC_COMPONENTE, vcampo.VLC_CLASE, vcampo.VLC_METODO, valor);
             break;
         default:
             pasaValidacion = false;
             break;
     }
     return pasaValidacion;
 }
        private bool EvaluarInclusionPorCondicion(int condicion, string valorValidacion, Valor valorCampoMensaje)
        {
            bool validacion;

            string valorAlfanumerico = valorCampoMensaje.ToString();
            int valorNumerico;
            int valorValidacionNumerico;
            bool valorCampoEsNumero = int.TryParse(valorAlfanumerico, out valorNumerico);
            bool valorValidacionEsNumero = int.TryParse(valorValidacion, out valorValidacionNumerico);

            switch (condicion)
            {
                case (int)EnumCondicion.Diferente:
                    validacion = (valorValidacion != valorAlfanumerico);
                    break;
                case (int)EnumCondicion.Igual:
                    validacion = (valorValidacion == valorAlfanumerico);
                    break;
                case (int)EnumCondicion.Mayor:
                    validacion = (valorCampoEsNumero && valorValidacionEsNumero && valorNumerico > valorValidacionNumerico);
                    break;
                case (int)EnumCondicion.MayorIgual:
                    validacion = (valorCampoEsNumero && valorValidacionEsNumero && valorNumerico >= valorValidacionNumerico);
                    break;
                case (int)EnumCondicion.Menor:
                    validacion = (valorCampoEsNumero && valorValidacionEsNumero && valorNumerico < valorValidacionNumerico);
                    break;
                case (int)EnumCondicion.MenorIgual:
                    validacion = (valorCampoEsNumero && valorValidacionEsNumero && valorNumerico <= valorValidacionNumerico);
                    break;
                default:
                    validacion = false;
                    break;
            }
            return validacion;
        }
 public string Encriptar(Valor palabra)
 {
     Valor llave = ObtenerLlave();
     return Algoritmo.Encriptar(llave, palabra, algoritmo);
 }
 private bool EvaluarComponente(string componente, string clase, string metodo, Valor valor)
 {
     object resultado= DllDinamica.Ejecutar(componente,clase,metodo,new[]{valor.ToString()});
     return Convert.ToBoolean(resultado);
 }
 private bool EvaluarProcedimiento(string procedimiento, Valor valor)
 {
     return FactoryDa.ValidarProcedure(procedimiento,valor.ToString());
 }
 private bool EvaluarInclusionPorTabla(string tabla, string columna, Valor valor)
 {
     return FactoryDa.ExisteEnTabla(tabla, columna, valor.ToString());
 }
 public virtual Valor Concat(Valor valor)
 {
     return new Caracter(Dato.ToString() + valor.ToString());
 }
 private void AgregarTransaccional(Valor valorTrama, ICollection<string> listaTransaccionales, StringBuilder transaccionales)
 {
     listaTransaccionales.Add(valorTrama.ToString());
     transaccionales.Append(valorTrama.ToString());
     transaccionales.Append(",");
 }
 private Valor Concatenacion(Valor llave1, Valor llave2)
 {
     return llave1.Concat(llave2);
 }