1004 lines
24 KiB
C
1004 lines
24 KiB
C
/* ipmip4_auth.h - ipmip4_auth.h */
|
|
/*
|
|
******************************************************************************
|
|
* HEADER FILE
|
|
*
|
|
* Document no: @(#) $Name: VXWORKS_ITER40_2019102207 $ $RCSfile: ipmip4_auth.h,v $ $Revision: 1.7 $
|
|
* $Source: /home/interpeak/CVSRoot/ipmip4/include/private/ipmip4_auth.h,v $
|
|
* $Author: jhorteli $ $Date: 2011-01-21 15:31:36 $
|
|
* $State: Exp $ $Locker: $
|
|
*
|
|
* INTERPEAK_COPYRIGHT_STRING
|
|
* Design and implementation by Joel Hortelius <joel.hortelius@interpeak.se>
|
|
******************************************************************************
|
|
*/
|
|
#ifndef IPMIP4_AUTH_H
|
|
#define IPMIP4_AUTH_H
|
|
|
|
/*
|
|
****************************************************************************
|
|
* 1 DESCRIPTION
|
|
****************************************************************************
|
|
* Basic authentication functions required for mobile IP. Deals with validation
|
|
* and creation of security associations.
|
|
*/
|
|
/*
|
|
DESCRIPTION
|
|
|
|
Basic authentication functions required for mobile IP. Deals with validation,
|
|
creation, configuration and setup of security associations.
|
|
|
|
In MIP4, secuirty association are usually secret passphrases associated with
|
|
an SPI number. The Mobility Entities provide the SPI number during their
|
|
registration, and a hash value of the registration frame. The receiving
|
|
entity validates the hash using the SPI passphrase.
|
|
|
|
In some instances, validation may be delegated to a AAA server using CHAP.
|
|
|
|
The third available authentication mechanism is key generation, where
|
|
key generation data is sent to a AAA server which will generate reply
|
|
data and SPI numbers back to the requesting entity. The requesting entity
|
|
will use its passphrase to generate a key. In this instance, the receiving
|
|
entity does not know the passphrase, but will only be provided with
|
|
with keygen material to be used for authentication.
|
|
|
|
|
|
EXAMPLE
|
|
|
|
These examples show how authentication methods are currently used in
|
|
MIP4.
|
|
|
|
.CS
|
|
|
|
IP_GLOBAL void
|
|
auth_function(struct Ipmip4my_context *ctx,
|
|
struct Ipmip_proc *proc,
|
|
Ipmip_buffer_t *buffer)
|
|
{
|
|
/@ Create the Authentication Context @/
|
|
Ipmip4_auth_context_t *auth_ctx = ipmip4_auth_context_create();
|
|
|
|
/@ Add a routing table to the Authentication Context @/
|
|
Ipmip4_auth_spi_table_t *auth_table = ipmip4_auth_spi_table_create(auth_ctx);
|
|
Ipmip4_auth_spi_hash_t *auth_hash = ipmip4_auth_spi_hash_create(auth_ctx);
|
|
Ipmip4_auth_spi_t *spi;
|
|
|
|
/@ Create a SPI @/
|
|
spi = ipmip4_auth_spi_create(proc, 1001, "my secret", sizeof("my secret"), IPMIP4_AUTH_METHOD_MD5_HMAC);
|
|
|
|
/@ Add a SPI to the Authentication Context @/
|
|
ipmip4_auth_spi_add(auth_ctx, spi);
|
|
|
|
/@ Add a reference in the routing table, saying that anything belonging to the
|
|
network 10.0.0.0/16 should use the provided SPI @/
|
|
ipmip4_auth_spi_table_add(auth_table, inet_addr("10.0.0.0"), 16, 1001);
|
|
|
|
/@ Add a reference in the hash table, saying that me@mydomain.com should
|
|
use the SPI @/
|
|
ipmip4_auth_spi_hash_add(auth_hash, "me@mydomain.com", sizeof("me@mydomain.com"), 1001);
|
|
|
|
/@ Retrieve the SPI for an address @/
|
|
spi = ipmip4_auth_spi_table_get(auth_table, inet_addr("10.0.1.1"));
|
|
|
|
/@ Sign the buffer based on the SPI @/
|
|
ipmip4_auth_append_mobile_to_home(buffer, spi);
|
|
|
|
/@ Retrieve the SPI for a NAI @/
|
|
spi = ipmip4_auth_spi_hash_get(auth_table, "me@mydomain.com", sizeof("me@mydomain.com"));
|
|
|
|
/@ Sign the buffer based on the SPI @/
|
|
ipmip4_auth_append_mobile_to_foreign(buffer, spi);
|
|
|
|
/@ Destroy the authentication table first @/
|
|
ipmip_auth_spi_table_destroy(auth_table);
|
|
|
|
/@ Destroy the authentication table first @/
|
|
ipmip_auth_spi_hash_destroy(auth_hash);
|
|
|
|
/@ Destroy the authentication context @/
|
|
ipmip_auth_context_destroy(auth_ctx);
|
|
}
|
|
|
|
.CE
|
|
*/
|
|
|
|
/*
|
|
****************************************************************************
|
|
* 2 CONFIGURATION
|
|
****************************************************************************
|
|
*/
|
|
|
|
/*
|
|
****************************************************************************
|
|
* 3 INCLUDE FILES
|
|
****************************************************************************
|
|
*/
|
|
|
|
#include <ipcom_route.h>
|
|
|
|
#include <private/ipmip_timer.h>
|
|
#include <private/ipmip_buffer.h>
|
|
|
|
#include <private/ipmip4_msgext.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*
|
|
****************************************************************************
|
|
* 4 DEFINES
|
|
****************************************************************************
|
|
*/
|
|
|
|
#define IPMIP4_AUTH_SPI_CHAP_SPI (2)
|
|
|
|
#define IPMIP4_AUTH_METHOD_MD5_HMAC (0)
|
|
#define IPMIP4_AUTH_METHOD_CHAP (1)
|
|
#define IPMIP4_AUTH_METHOD_KEYGEN (2)
|
|
|
|
#define IPMIP4_AUTH_ALG_HMAC_MD5 (1)
|
|
#define IPMIP4_AUTH_ALG_HMAC_SHA (2)
|
|
|
|
/*
|
|
****************************************************************************
|
|
* 5 TYPES
|
|
****************************************************************************
|
|
*/
|
|
|
|
struct Ipmip4_context;
|
|
struct Ipmip_proc;
|
|
struct Ipmip4_pktbuf;
|
|
struct Ipmip_cli_message;
|
|
|
|
typedef struct Ipmip4_auth_spi
|
|
{
|
|
Ipcom_list next;
|
|
Ip_u32 spi;
|
|
Ip_u8 method;
|
|
|
|
char *secret;
|
|
int secret_length;
|
|
}
|
|
Ipmip4_auth_spi_t;
|
|
|
|
typedef struct Ipmip4_auth_context
|
|
{
|
|
Ipcom_hash *spi_table;
|
|
} Ipmip4_auth_context_t;
|
|
|
|
typedef struct Ipmip4_auth_spi_table
|
|
{
|
|
Ipcom_route *rttable;
|
|
Ipmip4_auth_context_t *ctx;
|
|
} Ipmip4_auth_spi_table_t;
|
|
|
|
|
|
typedef struct Ipmip4_auth_spi_hash
|
|
{
|
|
Ipcom_hash *htable;
|
|
Ipmip4_auth_context_t *ctx;
|
|
} Ipmip4_auth_spi_hash_t;
|
|
|
|
/*
|
|
****************************************************************************
|
|
* 6 FUNCTIONS
|
|
****************************************************************************
|
|
*/
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_get - ipmip4_auth_spi_get
|
|
*
|
|
* Locates and returns the security parameter information corresponding
|
|
* to the provided SPI number in the Authentication Context.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i ctx
|
|
* Authentication Context
|
|
* \i spi
|
|
* Looked after SPI
|
|
* \ie
|
|
*
|
|
* RETURNS: The spi configuration structure if found
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_spi_t * ipmip4_auth_spi_get
|
|
(
|
|
Ipmip4_auth_context_t *ctx,
|
|
Ip_u32 spi
|
|
);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_context_create - ipmip4_auth_context_create
|
|
*
|
|
* This routine creates a authentication context for use with MIP4. An
|
|
* authentication context contains SPI to 'secret' mappings for use
|
|
* by authenticating entities to verify and create hash values.
|
|
*
|
|
* The Authentication Contexts are usually referenced by SPI hash tables
|
|
* and routing tables, which determine what SPI's should be used based
|
|
* on IP addresses and/or Network Access Identifiers.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* None.
|
|
*
|
|
* RETURNS: An SPI context
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_context_t * ipmip4_auth_context_create
|
|
(
|
|
void
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_context_destroy - ipmip4_auth_context_destroy
|
|
*
|
|
* Destroys an spi context and all associated values.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i authctx
|
|
* The SPI Authentication Context
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_context_destroy
|
|
(
|
|
Ipmip4_auth_context_t *authctx
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_free - ipmip4_auth_spi_free
|
|
*
|
|
* Free data associated with a security association.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i spi
|
|
* The spi
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_spi_free
|
|
(
|
|
Ipmip4_auth_spi_t *spi
|
|
);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_verify - ipmip4_auth_verify
|
|
*
|
|
* Verify an authentication header. This function can presumably return
|
|
* that the verification is in a pending state, since verification of said
|
|
* security associaton can be done by external mechanisms.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i ctx
|
|
* The generic mobility singleton context for IPMIP4. For each started mobility
|
|
* entity, there exists a mobility context which tracks configuration, system
|
|
* events, available features and started processes. The mobility context is
|
|
* created using ipmip4_context_create(). See ipmip4_context.h for
|
|
* more information regarding the mobility entity context singleton.
|
|
* \i proc
|
|
* The process context associated with the currently executing thread. Each
|
|
* thread and/or process in MIP must have its own unique process context.
|
|
* If a process is started using ipmip_proc_start, the process context will
|
|
* be allocated automatically by the IPMIP framework. Otherwise it must
|
|
* be allocated using ipmip_proc_alloc().
|
|
* \i pbuf
|
|
* The packet buffer
|
|
* \i uext
|
|
* The authentication extension.
|
|
* \i spi
|
|
* SPI to use.
|
|
* \i lock
|
|
* Pending lock
|
|
* \i func
|
|
* Pending function
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE if request is pending.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_verify
|
|
(
|
|
struct Ipmip4_context *ctx,
|
|
struct Ipmip_proc *proc,
|
|
struct Ipmip4_pktbuf *pbuf,
|
|
Ipmip4_msgext_uhdr_t *uext,
|
|
Ipmip4_auth_spi_t *spi,
|
|
Ipmip_timer_lock_t *lock,
|
|
Ipmip_timer_func_t func
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_table_create - ipmip4_auth_spi_table_create
|
|
*
|
|
* Creates a SPI table associated with an Authentication Context. A
|
|
* SPI table works as a routing table, locating the most explicit match.
|
|
* That is, if there is no exact match, the SPI table will locate the
|
|
* narrowest SPI that covers the asked for address.
|
|
*
|
|
* For example: If a table contains only one SPI with the following
|
|
* configuration: SPI: 1001, Network: 10.0.0.0/16 and someone asks for
|
|
* address 10.0.1.1, there exists no exact match, but SPI 1001 covers the
|
|
* searched for address, and will be returned.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i ctx
|
|
* Authentication Context
|
|
* \ie
|
|
*
|
|
* RETURNS: A newly allocated SPI table.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_spi_table_t * ipmip4_auth_spi_table_create
|
|
(
|
|
Ipmip4_auth_context_t *ctx
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_table_destroy - ipmip4_auth_spi_table_destroy
|
|
*
|
|
* Destroy an SPI table.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i rtab
|
|
* The SPI table
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_spi_table_destroy
|
|
(
|
|
Ipmip4_auth_spi_table_t *rtab
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_table_add - ipmip4_auth_spi_table_add
|
|
*
|
|
* Adds a SPI lookup reference to a SPI table. The SPI in question
|
|
* MUST exist in the Authentication Context, or this function call will
|
|
* fail. When a lookup rule is added, the result of that lookup
|
|
* is cached, so looked for SPIs must always be present.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i rtab
|
|
* The SPI table
|
|
* \i subnet
|
|
* The subnet this SPI covers
|
|
* \i plen
|
|
* The prefix length.
|
|
* \i spi
|
|
* The SPI to store.
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE on success, IP_FALSE otherwise
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_spi_table_add
|
|
(
|
|
Ipmip4_auth_spi_table_t *rtab,
|
|
Ip_u32 subnet,
|
|
Ip_u32 plen,
|
|
Ip_u32 spi
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_table_dump - ipmip4_auth_spi_table_dump
|
|
*
|
|
* Dump a SPI table
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i proc
|
|
* The process context associated with the currently executing thread. Each
|
|
* thread and/or process in MIP must have its own unique process context.
|
|
* If a process is started using ipmip_proc_start, the process context will
|
|
* be allocated automatically by the IPMIP framework. Otherwise it must
|
|
* be allocated using ipmip_proc_alloc().
|
|
* \i rtab
|
|
* The SPI table
|
|
* \i pre
|
|
* Pre text
|
|
* \i request
|
|
* The request structure
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_spi_table_dump
|
|
(
|
|
struct Ipmip_proc *proc,
|
|
Ipmip4_auth_spi_table_t *rtab,
|
|
const char *pre,
|
|
struct Ipmip_cli_message *request
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_hash_dump - ipmip4_auth_spi_hash_dump
|
|
*
|
|
* Dump a SPI hash table
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i proc
|
|
* The process context associated with the currently executing thread. Each
|
|
* thread and/or process in MIP must have its own unique process context.
|
|
* If a process is started using ipmip_proc_start, the process context will
|
|
* be allocated automatically by the IPMIP framework. Otherwise it must
|
|
* be allocated using ipmip_proc_alloc().
|
|
* \i hash
|
|
* The SPI hash table
|
|
* \i pre
|
|
* Pre text
|
|
* \i request
|
|
* The request structure
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_spi_hash_dump
|
|
(
|
|
struct Ipmip_proc *proc,
|
|
Ipmip4_auth_spi_hash_t *hash,
|
|
const char *pre,
|
|
struct Ipmip_cli_message *request
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_dump - ipmip4_auth_spi_dump
|
|
*
|
|
* Dump a SPI table
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i proc
|
|
* The process context associated with the currently executing thread. Each
|
|
* thread and/or process in MIP must have its own unique process context.
|
|
* If a process is started using ipmip_proc_start, the process context will
|
|
* be allocated automatically by the IPMIP framework. Otherwise it must
|
|
* be allocated using ipmip_proc_alloc().
|
|
* \i ctx
|
|
* The SPI context
|
|
* \i pre
|
|
* Pre text
|
|
* \i spi_subkey
|
|
* SPI is part of the subkey if TRUE, otherwise its own entry
|
|
* \i request
|
|
* The request structure
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_spi_dump
|
|
(
|
|
struct Ipmip_proc *proc,
|
|
Ipmip4_auth_context_t *ctx,
|
|
const char *pre,
|
|
Ip_bool spi_subkey,
|
|
struct Ipmip_cli_message *request
|
|
);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_table_get - ipmip4_auth_spi_table_get
|
|
*
|
|
* Get a SPI based on the address. The returned SPI is either an exact match,
|
|
* if one exists, or the narrowest covering subnet. If no match exists,
|
|
* IP_NULL will be returned.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i rtab
|
|
* The SPI table
|
|
* \i address
|
|
* The address we're looking for an SPI
|
|
* \ie
|
|
*
|
|
* RETURNS: The SPI or 0 on failure.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_spi_t * ipmip4_auth_spi_table_get
|
|
(
|
|
Ipmip4_auth_spi_table_t *rtab,
|
|
Ip_u32 address
|
|
);
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_hash_create - ipmip4_auth_spi_hash_create
|
|
*
|
|
* Creates a SPI hash table. An SPI hash table stores string key lookups,
|
|
* requiring a perfect match.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i ctx
|
|
* SPI Auth context
|
|
* \ie
|
|
*
|
|
* RETURNS: A newly allocated SPI hash table.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_spi_hash_t * ipmip4_auth_spi_hash_create
|
|
(
|
|
Ipmip4_auth_context_t *ctx
|
|
);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_hash_destroy - ipmip4_auth_spi_hash_destroy
|
|
*
|
|
* Destroy an SPI hash
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i htable
|
|
* The SPI hash table
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_spi_hash_destroy
|
|
(
|
|
Ipmip4_auth_spi_hash_t *htable
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_hash_add - ipmip4_auth_spi_hash_add
|
|
*
|
|
* Add a SPI to a spi hash table, and set its search keys
|
|
* to the appropriate values. The security association identified by
|
|
* SPI MUST exist in the Authentication Context referenced by the
|
|
* SPI Hash Table before lookup keys are added to it.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i htable
|
|
* The SPI hash table
|
|
* \i ident
|
|
* The identity
|
|
* \i ident_length
|
|
* The identity length
|
|
* \i spi
|
|
* The SPI to store.
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE on success, IP_FALSE otherwise
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_spi_hash_add
|
|
(
|
|
Ipmip4_auth_spi_hash_t *htable,
|
|
const char *ident,
|
|
Ip_size_t ident_length,
|
|
Ip_u32 spi
|
|
);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_hash_get - ipmip4_auth_spi_hash_get
|
|
*
|
|
* Get a SPI based on the provided string. The match must be exact.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i htable
|
|
* The SPI hash table
|
|
* \i ident
|
|
* The identity we're looking for.
|
|
* \i ident_length
|
|
* The length of the identity
|
|
* \ie
|
|
*
|
|
* RETURNS: The SPI or 0 on failure.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_spi_t * ipmip4_auth_spi_hash_get
|
|
(
|
|
Ipmip4_auth_spi_hash_t *htable,
|
|
const char *ident,
|
|
Ip_size_t ident_length
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_append_foreign_to_home - ipmip4_auth_append_foreign_to_home
|
|
*
|
|
* Append a foreign to home authentication
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i buf
|
|
* A pointer to an initialized dynamic mobility buffer. See ipmip_buffer.h
|
|
* for more information regarding dynamic buffers and their capabilities.
|
|
* \i spi
|
|
* The SPI to use.
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE if successful.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_append_foreign_to_home
|
|
(
|
|
Ipmip_buffer_t *buffer,
|
|
Ipmip4_auth_spi_t *spi
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_append_foreign_to_foreign - ipmip4_auth_append_foreign_to_foreign
|
|
*
|
|
* Append a foreign to foreign authentication
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i buf
|
|
* A pointer to an initialized dynamic mobility buffer. See ipmip_buffer.h
|
|
* for more information regarding dynamic buffers and their capabilities.
|
|
* \i spi
|
|
* The SPI to use.
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE if successful.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_append_foreign_to_foreign
|
|
(
|
|
Ipmip_buffer_t *buffer,
|
|
Ipmip4_auth_spi_t *spi
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_append_mobile_to_foreign - ipmip4_auth_append_mobile_to_foreign
|
|
*
|
|
* Append a mobile to foreign authentication
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i buf
|
|
* A pointer to an initialized dynamic mobility buffer. See ipmip_buffer.h
|
|
* for more information regarding dynamic buffers and their capabilities.
|
|
* \i spi
|
|
* The SPI to use.
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE if successful.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_append_mobile_to_foreign
|
|
(
|
|
Ipmip_buffer_t *buffer,
|
|
Ipmip4_auth_spi_t *spi
|
|
);
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_append_mobile_to_home - ipmip4_auth_append_mobile_to_home
|
|
*
|
|
* Append a mobile to home authentication
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i buf
|
|
* A pointer to an initialized dynamic mobility buffer. See ipmip_buffer.h
|
|
* for more information regarding dynamic buffers and their capabilities.
|
|
* \i spi
|
|
* The SPI to use.
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE if successful.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_append_mobile_to_home
|
|
(
|
|
Ipmip_buffer_t *buffer,
|
|
Ipmip4_auth_spi_t *spi
|
|
);
|
|
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_append_mobile_aaa - ipmip4_auth_append_mobile_aaa
|
|
*
|
|
* Append a mobile AAA authentication
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i buf
|
|
* A pointer to an initialized dynamic mobility buffer. See ipmip_buffer.h
|
|
* for more information regarding dynamic buffers and their capabilities.
|
|
* \i spi
|
|
* The SPI to use.
|
|
* \i challenge
|
|
* Optional challenge
|
|
* \ie
|
|
*
|
|
* RETURNS: IP_TRUE if successful.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL Ip_bool ipmip4_auth_append_mobile_aaa
|
|
(
|
|
Ipmip_buffer_t *buffer,
|
|
Ipmip4_auth_spi_t *spi,
|
|
Ipmip4_msgext_uhdr_t *challenge
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_add - ipmip4_auth_spi_add
|
|
*
|
|
* Add a SPI to a context
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i ctx
|
|
* SPI context
|
|
* \i spi
|
|
* SPI
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_spi_add
|
|
(
|
|
Ipmip4_auth_context_t *ctx,
|
|
Ipmip4_auth_spi_t *spi
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_create - ipmip4_auth_spi_create
|
|
*
|
|
* Create a security association based on the provided values.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i proc
|
|
* The process context associated with the currently executing thread. Each
|
|
* thread and/or process in MIP must have its own unique process context.
|
|
* If a process is started using ipmip_proc_start, the process context will
|
|
* be allocated automatically by the IPMIP framework. Otherwise it must
|
|
* be allocated using ipmip_proc_alloc().
|
|
* \i spival
|
|
* The selected SPI value
|
|
* \i secret
|
|
* The secret to use.
|
|
* \i secret_size
|
|
* The size of the secret
|
|
* \i method
|
|
* IPMIP4_AUTH_METHOD_MD5_HMAC,
|
|
*
|
|
* IPMIP4_AUTH_METHOD_CHAP or
|
|
*
|
|
* IPMIP4_AUTH_METHOD_KEYGEN
|
|
* \ie
|
|
*
|
|
* RETURNS: The created security association
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_spi_t * ipmip4_auth_spi_create
|
|
(
|
|
struct Ipmip_proc *proc,
|
|
Ip_u32 spival,
|
|
const void *secret,
|
|
Ip_size_t secret_size,
|
|
int method
|
|
);
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_spi_generate - ipmip4_auth_spi_generate
|
|
*
|
|
* Generate a security association based on the provided
|
|
* parameters. This method is used in order to generate SA's
|
|
* based on parameters retrieved in AAA key generation as defined
|
|
* in RFC3957
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i ctx
|
|
* The generic mobility singleton context for IPMIP4. For each started mobility
|
|
* entity, there exists a mobility context which tracks configuration, system
|
|
* events, available features and started processes. The mobility context is
|
|
* created using ipmip4_context_create(). See ipmip4_context.h for
|
|
* more information regarding the mobility entity context singleton.
|
|
* \i proc
|
|
* The process context associated with the currently executing thread. Each
|
|
* thread and/or process in MIP must have its own unique process context.
|
|
* If a process is started using ipmip_proc_start, the process context will
|
|
* be allocated automatically by the IPMIP framework. Otherwise it must
|
|
* be allocated using ipmip_proc_alloc().
|
|
* \i spival
|
|
* SPI to use for the SA
|
|
* \i alg
|
|
* The algoritm to use when generating. Currently
|
|
*
|
|
* IPMIP4_AUTH_ALG_HMAC_SHA or
|
|
*
|
|
* IPMIP4_AUTH_ALG_HMAC_MD5
|
|
* \i secret
|
|
* The secret
|
|
* \i secret_size
|
|
* Size of secret
|
|
* \i nonce
|
|
* Nonce
|
|
* \i nonce_size
|
|
* Size of the nonce
|
|
* \i identity
|
|
* Identity
|
|
* \i identity_size
|
|
* The size of identity
|
|
* \ie
|
|
*
|
|
* RETURNS: The generated and created SA on success.
|
|
*
|
|
* ERRNO:
|
|
*
|
|
*
|
|
*/
|
|
IP_GLOBAL Ipmip4_auth_spi_t * ipmip4_auth_spi_generate
|
|
(
|
|
struct Ipmip4_context *ctx,
|
|
struct Ipmip_proc *proc,
|
|
Ip_u32 spival,
|
|
int alg,
|
|
const void *secret,
|
|
Ip_size_t secret_size,
|
|
Ip_u8 *nonce,
|
|
Ip_size_t nonce_size,
|
|
Ip_u8 *identity,
|
|
Ip_size_t identity_size
|
|
);
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ipmip4_auth_init - ipmip4_auth_init
|
|
*
|
|
* Internal method. Invoked by ipmip4_context_init for initialization
|
|
* during startup.
|
|
*
|
|
* Parameters:
|
|
* \is
|
|
* \i ctx
|
|
* The generic mobility singleton context for IPMIP4. For each started mobility
|
|
* entity, there exists a mobility context which tracks configuration, system
|
|
* events, available features and started processes. The mobility context is
|
|
* created using ipmip4_context_create(). See ipmip4_context.h for
|
|
* more information regarding the mobility entity context singleton.
|
|
* \i proc
|
|
* The process context associated with the currently executing thread. Each
|
|
* thread and/or process in MIP must have its own unique process context.
|
|
* If a process is started using ipmip_proc_start, the process context will
|
|
* be allocated automatically by the IPMIP framework. Otherwise it must
|
|
* be allocated using ipmip_proc_alloc().
|
|
* \ie
|
|
*
|
|
* RETURNS: No return value
|
|
*
|
|
* ERRNO:
|
|
*
|
|
* NOMANUAL
|
|
*/
|
|
IP_GLOBAL void ipmip4_auth_init
|
|
(
|
|
struct Ipmip4_context *ctx,
|
|
struct Ipmip_proc *proc
|
|
);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|
|
/*
|
|
****************************************************************************
|
|
* END OF FILE
|
|
****************************************************************************
|
|
*/
|