233 lines
6.4 KiB
C
233 lines
6.4 KiB
C
/**
|
|
* @file authenticator.c
|
|
*
|
|
* @brief Implementation of authenticator.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2005 Jan Hutter, Martin Willi
|
|
* Hochschule fuer Technik Rapperswil
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* for more details.
|
|
*/
|
|
|
|
#include "authenticator.h"
|
|
|
|
#include <utils/allocator.h>
|
|
|
|
typedef struct private_authenticator_t private_authenticator_t;
|
|
|
|
/**
|
|
* Private data of an authenticator_t object.
|
|
*/
|
|
struct private_authenticator_t {
|
|
|
|
/**
|
|
* Public interface.
|
|
*/
|
|
authenticator_t public;
|
|
|
|
/**
|
|
* IKE_SA.
|
|
*/
|
|
protected_ike_sa_t *ike_sa;
|
|
|
|
/**
|
|
* A logger for.
|
|
*
|
|
* Using logger of IKE_SA.
|
|
*/
|
|
logger_t *logger;
|
|
|
|
/**
|
|
* TODO
|
|
*/
|
|
chunk_t (*allocate_octets) (private_authenticator_t *this,chunk_t last_message, chunk_t other_nonce,id_payload_t *my_id);
|
|
|
|
chunk_t (*allocate_auth_data_with_preshared_secret) (private_authenticator_t *this,chunk_t octets,chunk_t preshared_secret);
|
|
};
|
|
|
|
/**
|
|
* Implementation of authenticator_t.private_authenticator_t.
|
|
*/
|
|
static chunk_t allocate_octets(private_authenticator_t *this,chunk_t last_message, chunk_t other_nonce,id_payload_t *my_id)
|
|
{
|
|
chunk_t id_chunk = my_id->get_data(my_id);
|
|
u_int8_t id_with_header[4 + id_chunk.len];
|
|
chunk_t id_with_header_chunk;
|
|
chunk_t octets;
|
|
u_int8_t *current_pos;
|
|
prf_t *prf;
|
|
|
|
id_with_header[0] = my_id->get_id_type(my_id);
|
|
id_with_header[1] = 0x00;
|
|
id_with_header[2] = 0x00;
|
|
id_with_header[3] = 0x00;
|
|
memcpy(id_with_header + 4,id_chunk.ptr,id_chunk.len);
|
|
id_with_header_chunk.ptr = id_with_header;
|
|
id_with_header_chunk.len = sizeof(id_with_header);
|
|
|
|
prf = this->ike_sa->get_prf(this->ike_sa);
|
|
|
|
prf->set_key(prf,this->ike_sa->get_key_pr(this->ike_sa));
|
|
|
|
|
|
/* 4 bytes are id type and reserved fields of id payload */
|
|
octets.len = last_message.len + other_nonce.len + prf->get_block_size(prf);
|
|
octets.ptr = allocator_alloc(octets.len);
|
|
current_pos = octets.ptr;
|
|
memcpy(current_pos,last_message.ptr,last_message.len);
|
|
current_pos += last_message.len;
|
|
memcpy(current_pos,other_nonce.ptr,other_nonce.len);
|
|
current_pos += other_nonce.len;
|
|
prf->get_bytes(prf,id_with_header_chunk,current_pos);
|
|
|
|
this->logger->log_chunk(this->logger,RAW | MOST, "Octets (Mesage + Nonce + prf(Sk_px,Idx)",&octets);
|
|
return octets;
|
|
}
|
|
|
|
/**
|
|
* Implementation of authenticator_t.allocate_auth_data_with_preshared_secret.
|
|
*/
|
|
static chunk_t allocate_auth_data_with_preshared_secret (private_authenticator_t *this,chunk_t octets,chunk_t preshared_secret)
|
|
{
|
|
prf_t *prf = this->ike_sa->get_prf(this->ike_sa);
|
|
chunk_t auth_data;
|
|
chunk_t key_pad;
|
|
chunk_t key;
|
|
|
|
key_pad.ptr = "Key Pad for IKEv2";
|
|
key_pad.len = strlen(key_pad.ptr);
|
|
|
|
prf->set_key(prf,preshared_secret);
|
|
prf->allocate_bytes(prf,key_pad,&key);
|
|
prf->set_key(prf,key);
|
|
allocator_free_chunk(&key);
|
|
prf->allocate_bytes(prf,octets,&auth_data);
|
|
this->logger->log_chunk(this->logger,RAW | MORE, "Authenticated data",&auth_data);
|
|
|
|
return auth_data;
|
|
}
|
|
|
|
|
|
/**
|
|
* Implementation of authenticator_t.private_authenticator_t.
|
|
*/
|
|
|
|
static status_t verify_auth_data (private_authenticator_t *this,auth_payload_t *auth_payload, chunk_t last_received_packet,chunk_t my_nonce,id_payload_t *other_id_payload,bool *verified)
|
|
{
|
|
switch(auth_payload->get_auth_method(auth_payload))
|
|
{
|
|
case SHARED_KEY_MESSAGE_INTEGRITY_CODE:
|
|
{
|
|
chunk_t preshared_secret;
|
|
chunk_t auth_data = auth_payload->get_data(auth_payload);
|
|
|
|
preshared_secret.ptr = "secret";
|
|
preshared_secret.len = strlen(preshared_secret.ptr);
|
|
|
|
chunk_t octets = this->allocate_octets(this,last_received_packet,my_nonce,other_id_payload);
|
|
chunk_t my_auth_data = this->allocate_auth_data_with_preshared_secret(this,octets,preshared_secret);
|
|
allocator_free_chunk(&octets);
|
|
|
|
if (auth_data.len != my_auth_data.len)
|
|
{
|
|
*verified = FALSE;
|
|
allocator_free_chunk(&my_auth_data);
|
|
return SUCCESS;
|
|
}
|
|
if (memcmp(auth_data.ptr,my_auth_data.ptr,my_auth_data.len) == 0)
|
|
{
|
|
*verified = TRUE;
|
|
}
|
|
else
|
|
{
|
|
*verified = FALSE;
|
|
}
|
|
allocator_free_chunk(&my_auth_data);
|
|
return SUCCESS;
|
|
}
|
|
default:
|
|
{
|
|
return NOT_SUPPORTED;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implementation of authenticator_t.compute_auth_data.
|
|
*/
|
|
static status_t compute_auth_data (private_authenticator_t *this,auth_payload_t **auth_payload, chunk_t last_sent_packet,chunk_t other_nonce,id_payload_t *my_id_payload)
|
|
{
|
|
|
|
/* switch(auth_method)
|
|
{
|
|
case SHARED_KEY_MESSAGE_INTEGRITY_CODE:
|
|
{*/
|
|
|
|
chunk_t preshared_secret;
|
|
|
|
preshared_secret.ptr = "secret";
|
|
preshared_secret.len = strlen(preshared_secret.ptr);
|
|
|
|
chunk_t octets = this->allocate_octets(this,last_sent_packet,other_nonce,my_id_payload);
|
|
chunk_t auth_data = this->allocate_auth_data_with_preshared_secret(this,octets,preshared_secret);
|
|
|
|
allocator_free_chunk(&octets);
|
|
|
|
*auth_payload = auth_payload_create();
|
|
(*auth_payload)->set_auth_method((*auth_payload),SHARED_KEY_MESSAGE_INTEGRITY_CODE);
|
|
(*auth_payload)->set_data((*auth_payload),auth_data);
|
|
|
|
allocator_free_chunk(&auth_data);
|
|
allocator_free_chunk(&octets);
|
|
|
|
return SUCCESS;
|
|
/* }
|
|
default:
|
|
{
|
|
return NOT_SUPPORTED;
|
|
}
|
|
}*/
|
|
}
|
|
|
|
/**
|
|
* Implementation of authenticator_t.destroy.
|
|
*/
|
|
static void destroy (private_authenticator_t *this)
|
|
{
|
|
allocator_free(this);
|
|
}
|
|
|
|
/*
|
|
* Described in header.
|
|
*/
|
|
authenticator_t *authenticator_create(protected_ike_sa_t *ike_sa)
|
|
{
|
|
private_authenticator_t *this = allocator_alloc_thing(private_authenticator_t);
|
|
|
|
/* Public functions */
|
|
this->public.destroy = (void(*)(authenticator_t*))destroy;
|
|
this->public.verify_auth_data = (status_t (*) (authenticator_t *,auth_payload_t *, chunk_t ,chunk_t ,id_payload_t *,bool *)) verify_auth_data;
|
|
this->public.compute_auth_data = (status_t (*) (authenticator_t *,auth_payload_t **, chunk_t ,chunk_t ,id_payload_t *)) compute_auth_data;
|
|
|
|
/* private functions */
|
|
this->allocate_octets = allocate_octets;
|
|
this->allocate_auth_data_with_preshared_secret = allocate_auth_data_with_preshared_secret;
|
|
|
|
/* private data */
|
|
this->ike_sa = ike_sa;
|
|
this->logger = this->ike_sa->get_logger(this->ike_sa);
|
|
|
|
return &(this->public);
|
|
}
|