/// <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;
}