/// <summary> /// Prepara la instancia para realizar los cálculos, estableciendo la clave de /// autenticación. /// </summary> /// <remarks> /// 'clave_SHA' puede ser de cualquier tamaño, pero el recomendado es 64 bytes. /// Cada llamada a 'Inicia' debe tener la correspondiente llamada a 'Termina' (en un 'try', /// 'finally'). /// </remarks> /// <param name="clave_SHA">Clave de autenticación, de longitud 'BytesClave'.</param> internal void Inicia(Buzon clave_SHA) { #if DEBUG Depuracion.Asevera(algoritmo == null); Depuracion.Asevera(clave_SHA != null); Depuracion.Asevera(clave_SHA.Longitud > 0); #endif // byte [] entrada; if (clave_SHA.Inicio == 0 && clave_SHA.Datos.Length == clave_SHA.Longitud) { entrada = clave_SHA.Datos; } else { entrada = new byte [clave_SHA.Longitud]; clave_SHA.TomaBinario(0, entrada); } // algoritmo = new HMACSHA256(entrada); // #if DEBUG Depuracion.Asevera(algoritmo.CanReuseTransform); Depuracion.Asevera(algoritmo.CanTransformMultipleBlocks); Depuracion.Asevera(algoritmo.HashSize == BitsValor); #endif }
internal void EstableceSecreto(Buzon secreto) { Depuracion.Asevera(Seguridad.longitud_secreto == CifradoAES.BytesClave); Depuracion.Asevera(CifradoAES.BytesClave == CalculoHMAC.BytesValor); // if (cifrado_AES_local != null) { cifrado_AES_local.Termina(); } cifrado_AES_local = new CifradoAES(); if (cifrado_AES_remoto != null) { cifrado_AES_remoto.Termina(); } cifrado_AES_remoto = new CifradoAES(); if (calculo_HMAC_local != null) { calculo_HMAC_local.Termina(); } calculo_HMAC_local = new CalculoHMAC(); if (calculo_HMAC_remoto != null) { calculo_HMAC_remoto.Termina(); } calculo_HMAC_remoto = new CalculoHMAC(); // EstableceSecreto(secreto, true, true, "clave_encripta_cliente"); EstableceSecreto(secreto, true, false, "clave_encripta_servicio"); EstableceSecreto(secreto, false, true, "clave_autentica_cliente"); EstableceSecreto(secreto, false, false, "clave_autentica_servicio"); }
/// <summary> /// Calcula el código HMAC del mensaje y lo deja en el buzón indicado. /// </summary> /// <remarks> /// El buzón 'valor_HMAC' puede ser vacío; en ese caso se crea un array de bytes de longitud /// 'BytesValor' y se encapsula en el buzón. Si 'valor_HMAC' no es vacío, su longitud debe /// ser 'BytesValor'. /// </remarks> /// <param name="mensaje">Mensaje para el que se calcula el código HMAC.</param> /// <param name="valor_HMAC">Código HMAC calculado, de longitud BytesValor.</param> internal void Calcula(Buzon mensaje, Buzon valor_HMAC) { #if DEBUG Depuracion.Asevera(algoritmo != null); Depuracion.Asevera(mensaje != null); Depuracion.Asevera(mensaje.Longitud > 0); Depuracion.Asevera(valor_HMAC != null); if (valor_HMAC.Longitud > 0) { Depuracion.Asevera(valor_HMAC.Longitud == BytesValor); } #endif // byte [] retorno = algoritmo.ComputeHash(mensaje.Datos, mensaje.Inicio, mensaje.Longitud); // #if DEBUG Depuracion.Asevera(retorno.Length == BytesValor); #endif // if (valor_HMAC.Longitud == 0) { valor_HMAC.Construye(retorno); } else { Buffer.BlockCopy(retorno, 0, valor_HMAC.Datos, valor_HMAC.Inicio, BytesValor); } }
internal MensajeInicio(Seguridad seguridad_) : base(seguridad_) { Depuracion.Asevera(!seguridad_.DeServidor); // Prepara(); }
/// <summary> /// Prepara la instancia para generar los datos aleatorios. /// </summary> /// <remarks> /// Cada llamada a 'Inicia' debe tener la correspondiente llamada a 'Termina' (en un 'try', /// 'finally'). /// </remarks> internal void Inicia() { #if DEBUG Depuracion.Asevera(algoritmo == null); #endif // algoritmo = RandomNumberGenerator.Create(); //new RNGCryptoServiceProvider (); }
/// <summary> /// Genera datos aleatorios y los escribe en el buzón. /// </summary> /// <remarks> /// El numero de bytes generados es igual a la longitud del buzón. /// </remarks> /// <param name="data">Buzón donde se dejarán los datos aleatorios.</param> internal void Genera(Buzon data) { #if DEBUG Depuracion.Asevera(algoritmo != null); Depuracion.Asevera(data != null); Depuracion.Asevera(data.Longitud > 0); #endif // algoritmo.GetBytes(data.Datos); }
/// <summary> /// Incrementa el número de bloque usado en los contadores. Cada bloque de un mensaje debe /// ser distinto. /// </summary> /// <remarks> /// El contador queda preparado para ser leido (con 'AsignaContador'). /// </remarks> internal void IncrementaBloque() { Depuracion.Asevera(serie_iniciada); Depuracion.Asevera(contador_leido); Depuracion.Asevera(0 <= numero_bloque && numero_bloque < MaximoBloque); // numero_bloque++; // //PonNumeroBuzon (numero_bloque, inicio_bloque); // contador_leido = false; }
/// <summary> /// Copia el contador en el lugar indicado. /// </summary> /// <remarks> /// El contador debe estar preprado para ser leido. Esto se hace con 'IniciaSerie', /// 'IncrementaMensaje' o 'IncrementaBloque'. Tras copiarlo (con este método) el contador /// deja de estar preparado para ser leido. /// El buzón donde se copia el contador debe ser de longitud 'BytesContador'. /// </remarks> /// <param name="destino">Buzón donde se copiará en contador.</param> internal void AsignaContador(Buzon destino) { Depuracion.Asevera(destino != null); Depuracion.Asevera(destino.Longitud == BytesContador); Depuracion.Asevera(serie_iniciada); Depuracion.Asevera(!contador_leido); // PonNumeroBuzon(numero_serie, inicio_serie, destino); PonNumeroBuzon(numero_mensaje, inicio_mensaje, destino); PonNumeroBuzon(numero_bloque, inicio_bloque, destino); //Buffer.BlockCopy (buzon_contador, 0, destino.Datos, destino.Inicio, BytesContador); // contador_leido = true; }
/// <summary> /// Establece los primeros números a ser usados en los contadores. /// </summary> /// <remarks> /// Establece el número de serie 0, el número de mensaje 0 y el número de bloque 0. Se usa /// solo la primera vez que se cambia la serie, para las siguientes se usa 'CambiaSerie'. /// El contador queda preparado para ser leido (con 'AsignaContador'). /// </remarks> /// <param name="serie">marca de la nueva serie, </param> internal void Inicia() { Depuracion.Asevera(!serie_iniciada); // numero_serie = 0; numero_mensaje = 0; numero_bloque = 0; // //PonNumeroBuzon (numero_serie, inicio_serie); //PonNumeroBuzon (numero_mensaje, inicio_mensaje); //PonNumeroBuzon (numero_bloque, inicio_bloque); // serie_iniciada = true; contador_leido = false; }
/// <summary> /// Pone a cero el número de mensaje usado en los contadores. Se pone a cero para cambiar la /// clave de encriptación y la serie. /// </summary> /// <remarks> /// El número de serie y el número de bloque pasan a ser 0. /// Solo se puede usar este método cuando el número de serie y el número de mensaje no es 0. /// El contador queda preparado para ser leido (con 'AsignaContador'). /// </remarks> internal void AnulaMensaje() { Depuracion.Asevera(serie_iniciada); // se anula el mensaje tras cambiar la serie, cuando el contador no está leido: //Depuracion.Asevera (contador_leido); Depuracion.Asevera(numero_serie != 0); Depuracion.Asevera(numero_mensaje > 0); // numero_mensaje = 0; numero_bloque = 0; // //PonNumeroBuzon (numero_mensaje, inicio_mensaje); //PonNumeroBuzon (numero_bloque, inicio_bloque); // contador_leido = false; }
/// <summary> /// Incrementa el número de mensaje usado en los contadores. Se incrementa cuando hay un /// mensaje nuevo. /// </summary> /// <remarks> /// El número de bloque pasa a 0. /// Solo se puede usar este método cuando el número de serie y el número de mensaje no es 0. /// El contador queda preparado para ser leido (con 'AsignaContador'). /// </remarks> internal void IncrementaMensaje() { Depuracion.Asevera(serie_iniciada); Depuracion.Asevera(contador_leido); Depuracion.Asevera(numero_serie != 0); Depuracion.Asevera(numero_mensaje > 0); // if (numero_mensaje < MaximoMensaje) { numero_mensaje++; } else { numero_mensaje = 0; } numero_bloque = 0; // //PonNumeroBuzon (numero_mensaje, inicio_mensaje); //PonNumeroBuzon (numero_bloque, inicio_bloque); // contador_leido = false; }
/// <summary> /// Establece una nueva serie para ser usada en los contadores. La serie se asocia a una /// clave de encriptación nueva. /// </summary> /// <remarks> /// Los contadores de la serie usarán el número de serie indicado. El primer contador de /// la serie usará el número de mensaje 1 y el número de bloque 0. /// Solo se puede usar este método cuando el número de mensaje es 0. /// El número de serie indicado no puede ser 0 y debe ser distinto al de la serie anterior. /// El contador queda preparado para ser leido (con 'AsignaContador'). /// </remarks> /// <param name="serie">marca de la nueva serie, </param> internal void CambiaSerie(long serie) { Depuracion.Asevera(serie_iniciada); if (numero_serie != 0 || numero_mensaje != 0 || numero_bloque != 0) { Depuracion.Asevera(contador_leido); } Depuracion.Asevera(numero_mensaje == 0); Depuracion.Asevera(serie != 0); Depuracion.Asevera(numero_serie != serie); // numero_serie = serie; numero_mensaje = 1; numero_bloque = 0; // //PonNumeroBuzon (numero_serie, inicio_serie); //PonNumeroBuzon (numero_mensaje, inicio_mensaje); //PonNumeroBuzon (numero_bloque, inicio_bloque); // serie_iniciada = true; contador_leido = false; }