pluto实现分析(3)

 

本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，

严禁用于任何商业用途。
msn: yfydz_no1@hotmail.com
来源：http://yfydz.cublog.cn

5. 系统一些主要数据结构

5.1 SA ID

 

// IP地址结构
typedef struct {
// V4和V6地址的联合
 union {
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 } u;
} ip_address;

 

// 子网结构
typedef struct {
// 地址
 ip_address addr;
// 掩码位数
 int maskbits;
} ip_subnet;

#ifdef __KERNEL__
typedef __u32 ipsec_spi_t;
#else
typedef u_int32_t ipsec_spi_t;
#endif

// 包含3项: 目的地址, SPI和协议
typedef struct {  
        ip_address dst;  
        ipsec_spi_t spi; 
#  define SPI_PASS 256 
#  define SPI_DROP 257 
#  define SPI_REJECT 258 
#  define SPI_HOLD 259
#  define SPI_TRAP 260
#  define  SPI_TRAPSUBNET  261
 int proto;  
#  define SA_ESP 50 
#  define SA_AH 51 
#  define SA_IPIP 4 
#  define SA_COMP 108 
#  define SA_INT 61 
} ip_said;

5.2 连接(connection)

连接用于描述建立IPSec通道的连接信息, 参数直接的配置文件中配置, 连接可以是静态的, 也就是

两端地址等信息都是固定; 也可以是动态的, 也就是连接一方可以先不固定地址, 这时的连接只相当

于一个模板, 只有当真正有连接建立时再建立具体的连接实例。

struct connection {
// 连接名称
    char *name;
// 策略
    lset_t policy;
// IKE生命期
    time_t sa_ike_life_seconds;
// IPSEC连接生命期
    time_t sa_ipsec_life_seconds;
// 重协商间隔时间
    time_t sa_rekey_margin;
//
    unsigned long sa_rekey_fuzz;
// 重协商尝试次数
    unsigned long sa_keying_tries;
   
   
// DPD检查间隔时间
    time_t          dpd_delay;             
// DPD判断对方死亡时间,dpd_delay*dpd_tries
    time_t          dpd_timeout;           
// DPD对方死亡后判断操作
    enum dpd_action dpd_action;            
   
// 强制使用UDP封装(NAT穿越)
    bool               forceencaps;        
   
// 日志文件名称
    char              *log_file_name;      
// 日志文件流指针
    FILE              *log_file;           
    CIRCLEQ_ENTRY(connection) log_link;    
// 日志文件是否错误
    bool               log_file_err;       

// 安全策略路由
    struct spd_route spd;

   
// 实例序号, 有的连接是那种动态通配连接,开始时并没有明确的IP地址,只有连接时才建立实例
    unsigned long instance_serial;
// 策略优先权
    policy_prio_t prio;
// 实例初始化正确标志
    bool instance_initiation_ok; 
// 连接类型
    enum connection_kind kind;
// 网卡
    const struct iface_port *interface; 
// 是否已经初始化标志
    bool initiated;

// 与连接相关的状态的序列号
    so_serial_t 
 newest_isakmp_sa,
 newest_ipsec_sa;

#ifdef DEBUG
    lset_t extra_debugging;
#endif

   
// 地址协议族:V4, V6
    sa_family_t addr_family;  
// 通道内封装的地址的协议族
    sa_family_t tunnel_addr_family; 
// 下一策略
    struct connection *policy_next;

// 网关信息指针
    struct gw_info *gw_info;
// ESP使用算法名称
    char                *alg_esp;   
// IKE使用算法名称
    char                *alg_ike;   
// ESP算法信息
    struct alg_info_esp *alg_info_esp;
// IKE算法信息
    struct alg_info_ike *alg_info_ike;

// 主机对
    struct host_pair *host_pair;
// 主机对链表
    struct connection *hp_next; 

// 下一个连接
    struct connection *ac_next; 
// 证书信息   
    generalName_t *requested_ca; 
#ifdef XAUTH_USEPAM
// PAM认证句柄
    pam_handle_t  *pamh;  
#endif
};

// 安全策略路由结构
struct spd_route {
// 链表下一项
    struct spd_route *next;
// 本地和对方的端点信息
    struct end this;
    struct end that;
// 所有者
    so_serial_t eroute_owner;
// 路由状态类型
    enum routing_t routing; 
// 请求ID
    uint32_t reqid;
};

// 端点结构
struct end {
// 端点ID值,可为地址,也可以是一个字符串
    struct id id;
// 端点地址, 下一跳(网关)地址, 源地址
    ip_address
 host_addr,
 host_nexthop,
 host_srcip;
// 内部子网
    ip_subnet client;

// 一些标志
// 从DNS服务器获取key   
    bool key_from_DNS_on_demand;
// 存在子网
    bool has_client;
// 有通配子网
    bool has_client_wildcard;
// 有通配端口
    bool has_port_wildcard;
// 有通配ID
    bool has_id_wildcards;
// 启动停止命令文件
    char *updown;
// IKE端口
    u_int16_t host_port; 
// 指定了IKE端口
    bool      host_port_specific;
// 端口
    u_int16_t port;  
// 协议
    u_int8_t protocol;         
// 证书
    cert_t cert;  
// CA的名称
    chunk_t ca;   
// 属性表
    struct ietfAttrList *groups;
// smartcard
    smartcard_t *sc;  
#ifdef VIRTUAL_IP
// 虚拟IP(一般用于×××客户端)
    struct virtual_t *virt;
#endif
// 是XAUTH的服务器端
    bool xauth_server;
// 是XAUTH的客户端
    bool xauth_client;
// 是设置配置的服务器端, 可向客户端提供虚拟IP,DNS,WINS等参数
    bool modecfg_server;       
// 是设置配置的客户端
    bool modecfg_client;       
// 发送证书类型
    enum certpolicy sendcert;  
};

// ID结构
struct id {
// 类型
    int kind;  
// 地址
    ip_address ip_addr; 
// ID名称
    chunk_t name; 
   
};

 

5.2 状态(state)

状态是用于描述连接建立过程中的各种中间阶段，

struct state
{
// 状态序号
    so_serial_t        st_serialno;         
// 父状态序号
    so_serial_t        st_clonedfrom;       
// 状态使用数
    int                st_usage;

// 相关的连接指针
    struct connection *st_connection;         
// 与whack通信的接口描述符
    int                st_whack_sock;         
// 缓期的消息摘要
    struct msg_digest *st_suspended_md;       

// Oakley(主模式)转换属性参数
    struct oakley_trans_attrs st_oakley;

// AH协议信息
    struct ipsec_proto_info st_ah;
// ESP协议信息
    struct ipsec_proto_info st_esp;
// IP压缩协议信息
    struct ipsec_proto_info st_ipcomp;
#ifdef KLIPS
// 进入方向的SPI
    ipsec_spi_t        st_tunnel_in_spi;         
// 发出方向的SPI
    ipsec_spi_t        st_tunnel_out_spi;        
#endif

// 阶段2中使用的oakley组
    const struct oakley_group_desc *st_pfs_group;

// DOI解释域
    u_int32_t          st_doi;                
// 状况
    u_int32_t          st_situation;
// IPSEC SA策略
    lset_t             st_policy;             
// 对端地址
    ip_address         st_remoteaddr;         
// 对端的端口
    u_int16_t          st_remoteport;         

// 网卡   
    const struct iface_port *st_interface;    
// 本地地址和端口
    ip_address         st_localaddr;          
    u_int16_t          st_localport;          

// 消息ID
    msgid_t            st_msgid;              

// 消息ID
    msgid_t            st_msgid_phase15;      
    msgid_t            st_msgid_phase15b;     

   
// 使用的消息ID链表
    struct msgid_list  *st_used_msgids;       

 
// 发起方公共值
    chunk_t            st_gi;                 
// 发起方cookie
    u_int8_t           st_icookie[COOKIE_SIZE];
// 发起方时间
    chunk_t            st_ni;                 

 
// 接收方公共值
    chunk_t            st_gr;                 
// 接收方cookie
    u_int8_t           st_rcookie[COOKIE_SIZE];
// 接收方时间
    chunk_t            st_nr;                 

 
// 发送的包数
    chunk_t            st_tpacket;            

   
// 本地定义的协议和端口信息
    u_int8_t           st_myuserprotoid;      
    u_int16_t          st_myuserport;

 
// 接收的包数
    chunk_t            st_rpacket;            

   
// 对方的协议和端口信息
    u_int8_t           st_peeruserprotoid;    
    u_int16_t          st_peeruserport;

// 使用的密钥数
    u_int8_t           st_sec_in_use;     
// 本地秘密
    MP_INT             st_sec;            
// 本地秘密的备份
    chunk_t            st_sec_chunk;      
// 共享密钥
    chunk_t            st_shared;             
// 优先权
    enum crypto_importance st_import;         

   
// 对方的公钥
    struct pubkey     *st_peer_pubkey;
// 状态类型
    enum state_kind    st_state;              
// 重发数量
    u_int8_t           st_retransmit;         
// 重协商尝试次数
    unsigned long      st_try;                
                                              
// 有效时间
    time_t             st_margin;             
// 输出包数统计
    unsigned long      st_outbound_count;     
// 已经持续时间
    time_t             st_outbound_time;      
// 是否需要加密
    bool               st_calculating;        

// 阶段1的发起方进行哈希的SA载荷
    chunk_t            st_p1isa;              
// KEY ID
    chunk_t            st_skeyid;             
    chunk_t            st_skeyid_d;           
    chunk_t            st_skeyid_a;           
    chunk_t            st_skeyid_e;           
// 加密用的初始化向量
    u_char             st_iv[MAX_DIGEST_LEN]; 
// 老的初始化向量
    u_char             st_old_iv[MAX_DIGEST_LEN]; 
    u_char             st_new_iv[MAX_DIGEST_LEN];
// 阶段1的初始化向量
    u_char             st_ph1_iv[MAX_DIGEST_LEN];
// 各种初始化向量长度
    unsigned int       st_iv_len;
    unsigned int       st_old_iv_len;
    unsigned int       st_new_iv_len;
    unsigned int       st_ph1_iv_len;

// 加密密钥
    chunk_t            st_enc_key;            
// 状态链表的下一项和前一项
    struct state      *st_hashchain_next;     
    struct state      *st_hashchain_prev;     

// 内部参数
    struct {
// 接收到的错误数据包数
        unsigned int   st_malformed_received;
// 发送的错误数据包数
        unsigned int   st_malformed_sent;
// XAUTH客户端认证结束
 bool           st_xauth_client_done;
// XAUTH客户端认证尝试次数
 int            st_xauth_client_attempt;
// 模式配置服务器端处理结束
        bool           st_modecfg_server_done;
// 配置参数已经设置标志
        bool           st_modecfg_vars_set;
// 已经获得证书请求标志
 bool           st_got_certrequest;
// 模式配置启动标志
        bool           st_modecfg_started;
// 密钥ID已经计算标志
 bool           st_skeyid_calculated;
// 对方支持DPD标志
 bool           st_dpd;                
// 本地是否使用DPD标志
 bool           st_dpd_local;       
// 是否已经在日志中记录了算法标志
 bool           st_logged_p1algos;     
// NAT穿越参数
 u_int32_t      st_nat_traversal;      
// NAT前的地址
 ip_address     st_nat_oa;
// NAT后的地址
 ip_address     st_natd;
    } hidden_variables;                       

// XAUTH用户名
    unsigned char *st_xauth_username;

   
// 上次DPD时间
    time_t              st_last_dpd;           
// DPD包序号
    u_int32_t           st_dpd_seqno;          
// 期待的DPD包序号
    u_int32_t           st_dpd_expectseqno;    
// 对方的DPD序号
    u_int32_t           st_dpd_peerseqno;      
// DPD事件
    struct event        *st_dpd_event;         

// 看到的提供者ID
    u_int32_t       st_seen_vendorid;  
// 不同IPSEC实现互连时的一些错误信息
    struct isakmp_quirks quirks;         
   
};

 

// Oakley(第一阶段/主模式)转换和属性结构
struct oakley_trans_attrs {
// 加密算法
    u_int16_t encrypt;  
// 密钥长度
    u_int16_t enckeylen; 
// 加密算法描述结构
    const struct encrypt_desc *encrypter; 
// 哈希算法
    oakley_hash_t hash;  
// 哈希算法描述结构
    const struct hash_desc *hasher; 
// 认证算法
    oakley_auth_t auth;  
#ifdef XAUTH
// XAUTH认证
    u_int16_t xauth;           
#endif
// Oakley组描述结构
    const struct oakley_group_desc *group; 
// 生存期, 时间限制
    time_t life_seconds; 
// 生存期, 数据量限制
    u_int32_t life_kilobytes; 
#if 0
// 伪随机函数算法
    u_int16_t prf;  
#endif
};

 

// IPSEC(第2阶段/快速模式)转换和属性结构
struct ipsec_trans_attrs {
// 转换ID
    u_int8_t transid; 
// SPI
    ipsec_spi_t spi; 
// 生存期, 时间限制
    time_t life_seconds;  
// 生存期, 数据量限制
    u_int32_t life_kilobytes; 
// 封装类型
    u_int16_t encapsulation;
// 认证类型
    ipsec_auth_t auth;           
// 密钥长度
    u_int16_t key_len;
// 密钥计算轮数
    u_int16_t key_rounds;
#if 0
    u_int16_t cmprs_dict_sz;
    u_int32_t cmprs_alg;
#endif
};

// IPSEC协议信息
struct ipsec_proto_info {
// 是否提供标志
    bool present; 
// IPSEC(第2阶段/快速模式)转换和属性结构
    struct ipsec_trans_attrs attrs;
// 本地SPI
    ipsec_spi_t our_spi;
// 密钥长度
    u_int16_t keymat_len; 
// 本地密钥
    u_char *our_keymat;
// 对方密钥
    u_char *peer_keymat;
};

// 事件结构
struct event
{
// 事件事件
    time_t          ev_time;
// 事件类型
    enum event_type ev_type;       
// 事件相关的状态结构
    struct state   *ev_state;      
// 事件链表的下一项
    struct event   *ev_next;       
};

5.4 内核接口相关结构

// pfkey协议信息
struct pfkey_proto_info {
// 协议
 int proto;
// 封装类型
 int encapsulation;
// 请求ID
 unsigned reqid;
};

// 内核SA结构
struct kernel_sa {
// 源地址
 const ip_address *src;
// 目的地址
 const ip_address *dst;
// 源子网
 const ip_subnet *src_client;
// 目的子网
 const ip_subnet *dst_client;

// SPI
 ipsec_spi_t spi;
// 协议
 unsigned proto;
// SA类型
 unsigned satype;
// 回放窗口
 unsigned replay_window;
// 请求ID
 unsigned reqid;

// 认证算法
 unsigned authalg;
// 认证算法密钥长度
 unsigned authkeylen;
// 认证密钥
 char *authkey;

// 加密算法
 unsigned encalg;
// 加密算法密钥长度
 unsigned enckeylen;
// 加密密钥
 char *enckey;

// 封装
 int encapsulation;
#ifdef NAT_TRAVERSAL
// NAT穿越的源端口,目的端口
 u_int16_t natt_sport, natt_dport;
// ID和类型
 u_int8_t transid, natt_type;
// NAT转换前原地址
 ip_address *natt_oa;
#endif
// SA ID
 const char *text_said;
};

 

// 内核操作结构
struct kernel_ops {
// 枚举类型
 enum {
// 内核不支持
         KERNEL_TYPE_NONE,
// 内核使用KLIPS实现IPSEC
  KERNEL_TYPE_KLIPS,
// 内核使用自带的native ipsec
  KERNEL_TYPE_LINUX,
 } type;
// 操作名称
 const char *opname;
// 是否存在进入方向的加密路由
 bool inbound_eroute;
// 使用有策略生存期限制
 bool policy_lifetime;
// 回放窗口
        int  replay_window;
 int *async_fdp;

// 初始化
 void (*init)(void);
// 登记
 void (*pfkey_register)(void);
// 登记回应
 void (*pfkey_register_response)(const struct sadb_msg *msg);
// 队列处理
 void (*process_queue)(void);
// 处理消息
 void (*process_msg)(void);
// 原始加密路由处理
 bool (*raw_eroute)(const ip_address *this_host,
      const ip_subnet *this_client,
      const ip_address *that_host,
      const ip_subnet *that_client,
      ipsec_spi_t spi,
      unsigned int proto,
      unsigned int transport_proto,
      unsigned int satype,
      const struct pfkey_proto_info *proto_info,
      time_t use_lifetime,
      unsigned int op,
      const char *text_said);
// 增加SA
 bool (*add_sa)(const struct kernel_sa *sa, bool replace);
 bool (*grp_sa)(const struct kernel_sa *sa_outer,
         const struct kernel_sa *sa_inner);
// 删除SA
 bool (*del_sa)(const struct kernel_sa *sa);
// 获取SPI
 ipsec_spi_t (*get_spi)(const ip_address *src,
          const ip_address *dst,
          int proto,
          bool tunnel_mode,
          unsigned reqid,
          ipsec_spi_t min,
          ipsec_spi_t max,
          const char *text_said);
// 执行建立连接命令
    bool (*docommand)(struct connection *c
        , struct spd_route *sr
        , const char *verb
        , struct state *st);
};

// 加密路由信息
struct eroute_info {
// 包数
    unsigned long count;
// 本地子网
    ip_subnet ours;
// 对方子网
    ip_subnet his;
// 目的地址
    ip_address dst;
// SA ID
    ip_said said;
// 传输协议
    int         transport_proto;
// 链表下一项
    struct eroute_info *next;
};

5.5 密钥结构

// RSA公钥
struct RSA_public_key
{
// 密钥ID
    char keyid[KEYID_BUF]; 

   
// 长度
    unsigned k;

   
// 公钥参数
    MP_INT
 n, 
 e; 
};

// RSA私钥
struct RSA_private_key {
// 公钥结构, 因为私钥和公钥是对称的, 基本描述结构也相同
    struct RSA_public_key pub; 
// 私钥相关参数, 主要是一些内部私有数据
    MP_INT
 d, 
 
 p, 
 q, 
 dP, 
 dQ, 
 qInv; 
};

// 公开密钥结构
struct pubkey {
// ID结构
    struct id id;
// 使用数
    unsigned refcnt; 
// 认证层次
    enum dns_auth_level dns_auth_level;
// DNS签名
    char *dns_sig;
// 相关时间: 安装时间, 上次尝试时间, 上次工作时间, 到期时间
    time_t installed_time
 , last_tried_time
 , last_worked_time
 , until_time;
// 发布者
    chunk_t issuer;
// 公开密钥算法类型
    enum pubkey_alg alg;
// 公开密钥算法联合
    union {
// 目前只支持RSA这种公开密钥算法
 struct RSA_public_key rsa;
    } u;
};

// 公开密钥链表结构
struct pubkey_list {
    struct pubkey *key;
    struct pubkey_list *next;
};

...... 待续 ......