快速模式第二包: quick_inI1_ouR1()

文章目录

• • • 1. 序言
    • 2. quick_inI1_outR1()流程图
    • 3. 快速模式消息②数据包格式
    • 4. 源码分析
    • • 4.1 quick_inI1_outR1()
      • 4.2 quick_inI1_outR1_authtail()
      • 4.3 quick_inI1_outR1_cryptocontinue1()
      • 4.4 quick_inI1_outR1_cryptotail()
    • 5. 其他接口源码分析
    • • 5.1 decode_net_id()
      • 5.2 emit_subnet_id()
    • 6. 小结

1. 序言

在介绍第②包quick_inI1_outR1()函数之前，先说明下处理流程中的主要的功能：

• 协商第二阶段的SA算法信息，包括AH协议、ESP协议、封装模式等重要参数。
• 密钥材料交换，包括Nonce、KE(可选)。
• 使用ID载荷来协商两端的保护子网范围。
• 建立IPSec SA结构。
• 报文的认证和加密。

从上述作用可以看出，quick_inI1_outR1()及后续函数几乎实现了第一阶段的所有基本交换(第一阶段里的重要载荷在此流程中基本都有实现)，因此第二包处理流程算是IKEv1协商流程里最为复杂的流程了。这里只是做一个简单的笔记说明核心流程，无法涉及到完整的交换流程。此外响应端通过此次交换后会建立一个inbound sa,这部分流程尚未看明白处理逻辑(可能在于涉及到内核路由表等内容，目前还没有get到)。因此如果需要深入了解此流程，请参考源码实现。

2. quick_inI1_outR1()流程图

刚才已经说明第二个报文的处理流程比较复杂，实现的功能也较其他接口复杂了很多，从流程图上便可以看出：

3. 快速模式消息②数据包格式

下表中的报文格式有部分字段应该为变长类型，但是并未标出，这一点请注意。

4. 源码分析

4.1 quick_inI1_outR1()

quick_inI1_outR1()接口的作用包括：

• 检验报文的完整性

  • HASH载荷(杂凑载荷)既可以用来检验报文的完整性，也可以用来实现源认证功能，两者实际上是一致的。它计算范围是除了ISAKMP头部以外的完整报文进行杂凑运算。计算方式为:

    H

    A

    S

    H

    =

    P

    R

    F

    (

    S

    K

    E

    Y

    I

    D

    −

    a

    ,

    M

    s

    g

    I

    D

    ∣

    N

    i

    ∣

    S

    A

    ∣

    N

    r

    [

    ∣

    I

    D

    i

    ∣

    I

    D

    r

    ]

    )

    HASH = PRF(SKEYID-a, MsgID | Ni | SA | Nr [ | IDi | IDr ] )

    HASH=PRF(SKEYID−a,MsgID∣Ni∣SA∣Nr[∣IDi∣IDr])
    还需要注意的是快速模式的三个报文的HASH载荷的运算模式并不相同。

• 解析报文中的ID载荷

  • 快速模式中，身份标识ID载荷缺省定义为ISAKMP双方的协商地址。如果双方需要指定身份ID载荷，则需要按照一定的顺序进行传输：IDi + IDr。还需要注意的是协商隧道时配置的保护子网(感兴趣流)是通过ID载荷来传输并完成协商的。ID载荷可以传输IPv4和IPv6的主机地址、子网地址、地址范围。因此使用ID载荷来协商感兴趣流完全满足需求。使用emit_subnet_id()来将保护子网填充到ID载荷，使用decode_net_id()将ID载荷解析为保护子网地址.

• 保存IV值，并调用后续处理

quick_inI1_outR1()函数并没有协商保护子网信息，而是在后续接口中进行的协商。(NAT-T相关略)

stf_status
quick_inI1_outR1(struct msg_digest *md)
{
    const struct state *const p1st = md->st;
    struct connection *c = p1st->st_connection;
    struct payload_digest *const id_pd = md->chain[ISAKMP_NEXT_ID];
    struct verify_oppo_bundle b;    /* HASH(1) in *//*使用第一阶段的算法、计算并检验报文的hash载荷*/
    CHECK_QUICK_HASH(md
, quick_mode_hash12(hash_val, hash_pbs->roof, md->message_pbs.roof
    , p1st, &md->hdr.isa_msgid, FALSE)
, "HASH(1)", "Quick I1");    /* [ IDci, IDcr ] in
     * We do this now (probably out of physical order) because
     * we wish to select the correct connection before we consult
     * it for policy.
     */    if (id_pd != NULL)/*如果ID载荷存在*/
    {
struct payload_digest *IDci = id_pd->next;/* ??? we are assuming IPSEC_DOI *//* IDci (initiator is peer) */
if (!decode_net_id(&id_pd->payload.ipsec_id, &id_pd->pbs
   , &b.his.net, "peer client"))/*获取到对端的网段*/
    return STF_FAIL + INVALID_ID_INFORMATION;        /* Hack for MS 818043 NAT-T Update */
        if (id_pd->payload.ipsec_id.isaiid_idtype == ID_FQDN) {/*将单个地址转换为子网地址*/
            loglog(RC_LOG_SERIOUS, "Applying workaround for MS-818043 NAT-T bug");
            memset(&b.his.net, 0, sizeof(ip_subnet));
            happy(addrtosubnet(&c->spd.that.host_addr, &b.his.net));
}
        /* End Hack for MS 818043 NAT-T Update */        b.his.proto = id_pd->payload.ipsec_id.isaiid_protoid;
        b.his.port = id_pd->payload.ipsec_id.isaiid_port;
        b.his.net.addr.u.v4.sin_port = htons(b.his.port);        /* IDcr (we are responder) */        if (!decode_net_id(&IDci->payload.ipsec_id, &IDci->pbs
                   , &b.my.net, "our client"))
            return STF_FAIL + INVALID_ID_INFORMATION;        b.my.proto = IDci->payload.ipsec_id.isaiid_protoid;
        b.my.port = IDci->payload.ipsec_id.isaiid_port;
        b.my.net.addr.u.v4.sin_port = htons(b.my.port);#ifdef NAT_TRAVERSAL
        /*
         * 略
         */
#endif
    }
    else
    {  /*载荷中不存在ID载荷，如果两端的地址类型不一致的化则返回错误
        *
        *如果不存在ID载荷，则使用协商地址作为保护子网
        */
        /* implicit IDci and IDcr: peer and self */
        if (!sameaddrtype(&c->spd.this.host_addr, &c->spd.that.host_addr))
            return STF_FAIL;
    /*默认使用IP地址当作ID*/
        happy(addrtosubnet(&c->spd.this.host_addr, &b.my.net));
        happy(addrtosubnet(&c->spd.that.host_addr, &b.his.net));
        b.his.proto = b.my.proto = 0;
        b.his.port = b.my.port = 0;
    }
    b.step = vos_start;
    b.md = md;
    b.new_iv_len = p1st->st_new_iv_len;
    save_new_iv(p1st, b.new_iv);    /*
     * FIXME - DAVIDM
     * "b" is on the stack,  for OPPO  tunnels this will be bad, in
     * quick_inI1_outR1_start_query it saves a pointer to it before
     * a crypto (async op).
     */
return quick_inI1_outR1_authtail(&b, NULL);
}

4.2 quick_inI1_outR1_authtail()

quick_inI1_outR1_authtail()函数作用包括如下几个：

• 根据子网信息查询连接

  这部分代码没有看懂。。按常理来说，接收此报文时已经确定了连接和状态信息，直接比较连接上的保护子网信息和SA载荷中的保护子网信息，确定是否匹配即可。但是openswan源码中的逻辑负责了很多，没有看明白这部分代码，先留一个疑问吧。

• 根据连接创建新的状态

• 解析IPSec SA建议载荷

  • 解析SA载荷：parse_ipsec_sa_body()

    这个接口是快速模式协商IPSec策略的核心接口，包括封装协议 (ESP | AH | IPCOM)、加密算法、认证算法(完整性算法)、隧道模式or传输模式等等，都是在此接口中进行协商的。此外，该函数也可以完成应答报文的SA载荷的封装。

    近700行的代码，不再另行说明了。

• 解析Nonce载荷

• 如果支持PFS，则解析KE载荷

  • 启动PFS功能(完美向前加密)，则第二阶段需要再进行一次DH交换，因此需要重新计算生成KE载荷。PFS简单的说如果第一阶段的秘钥被破解(无论采用何种方式)，由第一阶段密钥衍生的第二阶段密钥则不受影响。这就要求在第二阶段再次进行DH交换。

• 构建密钥交换材料申请结构信息，包括：

  • 本端的KE载荷
  • 本端的Nonce载荷

static stf_status
quick_inI1_outR1_authtail(struct verify_oppo_bundle *b
      , struct adns_continuation *ac)
{
    struct msg_digest *md = b->md;
    struct state *const p1st = md->st;
    struct connection *c = p1st->st_connection;
    ip_subnet *our_net = &b->my.net
, *his_net = &b->his.net;
    struct end our, peer;
    struct hidden_variables hv;    zero(&our); zero(&peer);
    our.host_type  = KH_IPADDR;
    our.client     = b->my.net;
    our.port       = b->my.port;
    our.protocol   = b->my.proto;
    our.has_client = TRUE;    peer.host_type  = KH_IPADDR;
    peer.client     = b->his.net;
    peer.port       = b->his.port;
    peer.protocol   = b->his.proto;
    peer.has_client = TRUE;    /*log信息*/    /* Now that we have identities of client subnets, we must look for
     * a suitable connection (our current one only matches for hosts).
     */struct connection *p = find_client_connection(c, &our, &peer);/*根据两端的保护子网来查询连接*/
... ...    /* now that we are sure of our connection, create our new state */
    {
struct state *const st = duplicate_state(p1st);/* first: fill in missing bits of our new state object
 * note: we don't copy over st_peer_pubkey, the public key
 * that authenticated the ISAKMP SA.  We only need it in this
 * routine, so we can "reach back" to p1st to get it.
 */
if (st->st_connection != c)
{
    struct connection *t = st->st_connection;    st->st_connection = c;
    set_cur_connection(c);
    connection_discard(t);
}st->st_try = 0;/* not our job to try again from start */st->st_msgid = md->hdr.isa_msgid;st->st_new_iv_len = b->new_iv_len;
set_new_iv(st, b->new_iv);set_cur_state(st);/* (caller will reset) */
md->st = st;        /* feed back new state */st->st_peeruserprotoid = b->his.proto;
st->st_peeruserport = b->his.port;
st->st_myuserprotoid = b->my.proto;
st->st_myuserport = b->my.port;change_state(st, STATE_QUICK_R0);insert_state(st);/* needs cookies, connection, and msgid *//* copy hidden variables (possibly with changes) */
st->hidden_variables = hv;/* copy the connection's
 * IPSEC policy into our state.  The ISAKMP policy is water under
 * the bridge, I think.  It will reflect the ISAKMP SA that we
 * are using.
 */
st->st_policy = (p1st->st_policy & POLICY_ID_AUTH_MASK)
    | (c->policy & ~POLICY_ID_AUTH_MASK);#ifdef NAT_TRAVERSAL
...
#endifpassert(st->st_connection != NULL);
passert(st->st_connection == c);/* process SA in */
{
    struct payload_digest *const sapd = md->chain[ISAKMP_NEXT_SA];
    pb_stream in_pbs = sapd->pbs;    /* parse and accept body, setting variables, but not forming
     * our reply. We'll make up the reply later on.
     *
     * note that we process the copy of the pbs, so that
     * we can process it again in the cryptotail().
     */
    st->st_pfs_group = &unset_group;
    RETURN_STF_FAILURE(parse_ipsec_sa_body(&in_pbs
   , &sapd->payload.sa
   , NULL
   , FALSE, st));
}/* Ni in *//*Nonce载荷存储在state上*/
RETURN_STF_FAILURE(accept_v1_nonce(md, &st->st_ni, "Ni"));/* [ KE ] in (for PFS) *//*KE载荷存储在state上*/
RETURN_STF_FAILURE(accept_PFS_KE(md, &st->st_gi
 , "Gi", "Quick Mode I1"));/*本端的KE和NONCE载荷哪里进行的填充???*/passert(st->st_pfs_group != &unset_group);passert(st->st_connection != NULL);{/*根据发起端的KE和Nonce载荷，生成本端的ke和Nonce材料*/
    struct qke_continuation *qke = alloc_thing(struct qke_continuation
      , "quick_outI1 KE");    stf_status e;
    enum crypto_importance ci;    ci = pcim_ongoing_crypto;
    if(ci < st->st_import) ci = st->st_import;    qke->md = md;
    pcrc_init(&qke->qke_pcrc);
    qke->qke_pcrc.pcrc_func = quick_inI1_outR1_cryptocontinue1;    if (st->st_pfs_group != NULL) {/*支持PFS???*/
e = build_ke(&qke->qke_pcrc, st, st->st_pfs_group, ci);
    } else {
e = build_nonce(&qke->qke_pcrc, st, ci);
    }    passert(st->st_connection != NULL);    return e;
}
    }
}

4.3 quick_inI1_outR1_cryptocontinue1()

quick_inI1_outR1_cryptocontinue1()函数的作用如下：

• 提取计算得到的Nonce载荷
• 如果启动PFS功能，则计算DH密钥信息
• 如果未启动PFS功能，则进行应答报文封装操作

static void
quick_inI1_outR1_cryptocontinue1(struct pluto_crypto_req_cont *pcrc
 , struct pluto_crypto_req *r
 , err_t ugh)
{
    struct qke_continuation *qke = (struct qke_continuation *)pcrc;
    struct msg_digest *md = qke->md;
    struct state *const st = state_with_serialno(qke->qke_pcrc.pcrc_serialno);/*根据序号查找状态*/
    stf_status e;    set_cur_state(st);/* we must reset before exit */
    st->st_calculating=FALSE;
    set_suspended(st, NULL);    /* we always calcualte a nonce */
    unpack_nonce(&st->st_nr, r);/*提取Nonce值*/    if (st->st_pfs_group != NULL) {/*如果支持PFS,则需要进行第二次DH协商*/
struct dh_continuation *dh = alloc_thing(struct dh_continuation
 , "quick outR1 DH");unpack_KE(st, r, &st->st_gr);/* set up second calculation */
dh->md = md;
set_suspended(st, md);
pcrc_init(&dh->dh_pcrc);
dh->dh_pcrc.pcrc_func = quick_inI1_outR1_cryptocontinue2;
e = start_dh_secret(&dh->dh_pcrc, st
    , st->st_import
    , RESPONDER
    , st->st_pfs_group->group);/* In the STF_INLINE, quick_inI1_outR1_cryptocontinue1 has already
 * called complete_v1_state_transition and it has freed *dh. It
 * called quick_inI1_outR1_cryptocontinue2 which did the release_md too.
 */
if(e != STF_SUSPEND && e != STF_INLINE) {
    if(dh->md != NULL) {
complete_v1_state_transition(&qke->md, e);
if(dh->md) release_md(qke->md);
    }
}    } else {/*无需第二次DH协商*/
/* but if PFS is off, we don't do a second DH, so
 * just call the continuation after making something up.
 */
struct dh_continuation dh;dh.md=md;e = quick_inI1_outR1_cryptotail(&dh, NULL);
if(e == STF_OK) {if(dh.md != NULL) {
    /* note: use qke-> pointer */
    complete_v1_state_transition(&qke->md, e);
    if(dh.md)
release_md(qke->md);
}
}
    }
    reset_cur_state();
}

4.4 quick_inI1_outR1_cryptotail()

quick_inI1_outR1_cryptotail()函数的作用如下：

• 构建应答报文

  • ISAKMP头部
  • HASH载荷
  • SA载荷
  • Nonce载荷
  • KE载荷
  • ID载荷

• 计算报文的哈希值

• 生成密钥材料：compute_keymats

  • 不同协议生成不同的keymats, 如AH、ESP分别生成不同的keymats。

  • 计算公式：

    K

    E

    Y

    M

    A

    T

    =

    P

    R

    F

    (

    S

    K

    E

    Y

    I

    D

    —

    d

    ,

    p

    r

    o

    t

    o

    c

    o

    l

    ∣

    S

    P

    I

    ∣

    N

    i

    −

    b

    ∣

    N

    r

    −

    b

    )

    KEYMAT = PRF(SKEYID—d, protocol | SPI | Ni-b | Nr-b)

    KEYMAT=PRF(SKEYID—d,protocol∣SPI∣Ni−b∣Nr−b)

  • 实现中将所有算法需要的密钥长度全部相加，通过反馈连接方法从而生成所需长度的密钥材料。

• 建立入ipsec sa: install_inbound_ipsec_sa

  • 最最关键的部分没看懂…

• 加密报文

static stf_status
quick_inI1_outR1_cryptotail(struct dh_continuation *dh
   , struct pluto_crypto_req *r)
{
    struct msg_digest *md = dh->md;
    struct state *st = md->st;
    struct payload_digest *const id_pd = md->chain[ISAKMP_NEXT_ID];
    struct payload_digest *const sapd = md->chain[ISAKMP_NEXT_SA];
    struct isakmp_sa sa = sapd->payload.sa;
    pb_stream r_sa_pbs;
    u_char/* set by START_HASH_PAYLOAD: */
*r_hashval,/* where in reply to jam hash value */
*r_hash_start;/* from where to start hashing */    /* Start the output packet.
     *
     * proccess_packet() would automatically generate the HDR*
     * payload if smc->first_out_payload is not ISAKMP_NEXT_NONE.
     * We don't do this because we wish there to be no partially
     * built output packet if we need to suspend for asynch DNS.
     *
     * We build the reply packet as we parse the message since
     * the parse_ipsec_sa_body emits the reply SA
     */    /* HDR* out */
    echo_hdr(md, TRUE, ISAKMP_NEXT_HASH);    /* HASH(2) out -- first pass *//*填充HASH载荷并清零hash数据部分*/
    START_HASH_PAYLOAD(md->rbody, ISAKMP_NEXT_SA);    passert(st->st_connection != NULL);    /* sa header is unchanged -- except for np *//*SA载荷头部未发生改变，直接填充即可*/
    sa.isasa_np = ISAKMP_NEXT_NONCE;
    if (!out_struct(&sa, &isakmp_sa_desc, &md->rbody, &r_sa_pbs))
return STF_INTERNAL_ERROR;    /* parse and accept body, this time recording our reply *//*再次匹配SA载荷，然后将
   * 匹配的SA载荷填充到r_sa_pbs中*/
    RETURN_STF_FAILURE(parse_ipsec_sa_body(&sapd->pbs
   , &sapd->payload.sa
   , &r_sa_pbs
   , FALSE, st));    /**** packet payload: HDR SA Nr [, KE ] [, IDci, IDcr ] ****/
    passert(st->st_pfs_group != &unset_group);    if ((st->st_policy & POLICY_PFS) && st->st_pfs_group == NULL) {
loglog(RC_LOG_SERIOUS, "we require PFS but Quick I1 SA specifies no GROUP_DESCRIPTION");
return STF_FAIL + NO_PROPOSAL_CHOSEN;/* ??? */
    }    openswan_log("responding to Quick Mode proposal {msgid:%08x}", st->st_msgid);
    {
char instbuf[END_BUF];
struct connection *c = st->st_connection;
struct spd_route *sr = &c->spd;format_end(instbuf, sizeof(instbuf),&sr->this,&sr->that,TRUE, LEMPTY);
openswan_log("    us: %s", instbuf);format_end(instbuf, sizeof(instbuf),&sr->that,&sr->this,FALSE, LEMPTY);openswan_log("  them: %s", instbuf);
    }    /**** finish reply packet: Nr [, KE ] [, IDci, IDcr ] ****/    {
int np;
#ifdef IMPAIR_UNALIGNED_R1_MSG
char *padstr=getenv("PLUTO_UNALIGNED_R1_MSG");if(padstr) {
    np = ISAKMP_NEXT_VID;
} else
#endif
if(st->st_pfs_group != NULL) {
    np = ISAKMP_NEXT_KE;
} else if(id_pd != NULL) {
    np = ISAKMP_NEXT_ID;
} else {
    np = ISAKMP_NEXT_NONE;
}/* Nr out */
if (!justship_nonce(&st->st_nr, &md->rbody, np, "Nr"))
    return STF_INTERNAL_ERROR;#ifdef IMPAIR_UNALIGNED_R1_MSG
if(padstr) {
    pb_stream vid_pbs;
    int padsize;
    padsize = strtoul(padstr, NULL, 0);    openswan_log("inserting fake VID payload of %u size", padsize);    if(st->st_pfs_group != NULL) {
np = ISAKMP_NEXT_KE;
    } else if(id_pd != NULL) {
np = ISAKMP_NEXT_ID;
    } else {
np = ISAKMP_NEXT_NONE;
    }    if (!out_generic(np,
     &isakmp_vendor_id_desc, &md->rbody, &vid_pbs))
return STF_INTERNAL_ERROR;    if (!out_zero(padsize, &vid_pbs, "Filler VID"))
return STF_INTERNAL_ERROR;    close_output_pbs(&vid_pbs);
}
#endif
    }    /* [ KE ] out (for PFS) */
    if (st->st_pfs_group != NULL && r!=NULL) {
if (!justship_KE(&st->st_gr
 , &md->rbody
 , id_pd != NULL? ISAKMP_NEXT_ID : ISAKMP_NEXT_NONE))
    return STF_INTERNAL_ERROR;finish_dh_secret(st, r);
        if(!r->pcr_success) {
            return STF_FAIL + INVALID_KEY_INFORMATION;
        }
    }    /* [ IDci, IDcr ] out */
    if  (id_pd != NULL){
struct isakmp_ipsec_id *p = (void *)md->rbody.cur;/* UGH! */if (!out_raw(id_pd->pbs.start, pbs_room(&id_pd->pbs), &md->rbody, "IDci"))
    return STF_INTERNAL_ERROR;
p->isaiid_np = ISAKMP_NEXT_ID;p = (void *)md->rbody.cur;/* UGH! */if (!out_raw(id_pd->next->pbs.start, pbs_room(&id_pd->next->pbs), &md->rbody, "IDcr"))
    return STF_INTERNAL_ERROR;
p->isaiid_np = ISAKMP_NEXT_NONE;
    }#ifdef TPM
    {
pb_stream *pbs = &md->rbody;
size_t enc_len = pbs_offset(pbs) - sizeof(struct isakmp_hdr);TCLCALLOUT_crypt("preHash", st,pbs,sizeof(struct isakmp_hdr),enc_len);
r_hashval = tpm_relocateHash(pbs);
    }
#endif    /* Compute reply HASH(2) and insert in output */
    (void)quick_mode_hash12(r_hashval, r_hash_start, md->rbody.cur
    , st, &st->st_msgid, TRUE);    /* Derive new keying material */
    compute_keymats(st);    /* Tell the kernel to establish the new inbound SA
     * (unless the commit bit is set -- which we don't support).
     * We do this before any state updating so that
     * failure won't look like success.
     */
    if (!install_inbound_ipsec_sa(md->pst, st))
return STF_INTERNAL_ERROR;/* ??? we may be partly committed */    /* encrypt message, except for fixed part of header */    if (!encrypt_message(&md->rbody, st))
    {
delete_ipsec_sa(st, TRUE);
return STF_INTERNAL_ERROR;/* ??? we may be partly committed */
    }    DBG(DBG_CONTROLMORE, DBG_log("finished processing quick inI1"));
    return STF_OK;
}

5. 其他接口源码分析

5.1 decode_net_id()

decode_net_id()函数的作用：

• 解析报文中的ID载荷,并将主机地址、子网地址、地址范围转换为子网信息。

  这里解析的子网信息用于协商感兴趣流(保护子网)参数

  • 如果类型为“ID_IPV4_ADDR”或者“ID_IPV6_ADDR”，则说明为单个主机地址，解析后转换为子网地址，掩码长度为32位；
  • 如果类型为”ID_IPV4_ADDR_SUBNET”或者“ID_IPV6_ADDR_RANGE”，则表明ID载荷数据部分是子网信息，包含两部分：网络地址和子网掩码。通过网络地址和子网掩码共同确定保护子网信息。
  • 如果类型为“ID_IPV4_ADDR_RANGE”或者“ID_IPV6_ADDR_RANGE”，则同样表明ID载荷数据是一个地址范围，包含两部分内容：起始地址和终止地址。需要注意的时，这里目前仅支持标准的子网范围，而非任意子网范围，这点需要注意(详情参见rangetosubnet())。

static bool
decode_net_id(struct isakmp_ipsec_id *id
, pb_stream *id_pbs
, ip_subnet *net
, const char *which)
{
    const struct af_info *afi = NULL;    /* Note: the following may be a pointer into static memory
     * that may be recycled, but only if the type is not known.
     * That case is disposed of very early -- in the first switch.
     */
    const char *idtypename = enum_show(&ident_names, id->isaiid_idtype);
/*
* 子网ID可能为单个地址、子网、子网范围
*
*/
    switch (id->isaiid_idtype)
    {
case ID_IPV4_ADDR:
case ID_IPV4_ADDR_SUBNET:
case ID_IPV4_ADDR_RANGE:
    afi = &af_inet4_info;
    break;
case ID_IPV6_ADDR:
case ID_IPV6_ADDR_SUBNET:
case ID_IPV6_ADDR_RANGE:
    afi = &af_inet6_info;
    break;
case ID_FQDN:
    loglog(RC_COMMENT, "%s type is FQDN", which);
    return TRUE;default:
    /* XXX support more */
    loglog(RC_LOG_SERIOUS, "unsupported ID type %s"
, idtypename);
    /* XXX Could send notification back */
    return FALSE;
    }    switch (id->isaiid_idtype)
    {
case ID_IPV4_ADDR:/*ID载荷为单个地址*/
case ID_IPV6_ADDR:
{
    ip_address temp_address;
    err_t ughmsg;    ughmsg = initaddr(id_pbs->cur, pbs_left(id_pbs), afi->af, &temp_address);    if (ughmsg != NULL)
    {
loglog(RC_LOG_SERIOUS, "%s ID payload %s has wrong length in Quick I1 (%s)"
    , which, idtypename, ughmsg);
/* XXX Could send notification back */
return FALSE;
    }
    if (isanyaddr(&temp_address))
    {
loglog(RC_LOG_SERIOUS, "%s ID payload %s is invalid (%s) in Quick I1"
    , which, idtypename, ip_str(&temp_address));
/* XXX Could send notification back */
return FALSE;
    }
    happy(addrtosubnet(&temp_address, net));/*将单个地址解析为保护子网地址*/
    DBG(DBG_PARSING | DBG_CONTROL
, DBG_log("%s is %s", which, ip_str(&temp_address)));
    break;
}case ID_IPV4_ADDR_SUBNET:/*如果ID为子网信息*/
case ID_IPV6_ADDR_SUBNET:
{
    ip_address temp_address, temp_mask;
    err_t ughmsg;    if (pbs_left(id_pbs) != 2 * afi->ia_sz)/*子网信息包括IP和掩码，因此长度*2  */
    {
loglog(RC_LOG_SERIOUS, "%s ID payload %s wrong length in Quick I1"
    , which, idtypename);
/* XXX Could send notification back */
return FALSE;
    }
    ughmsg = initaddr(id_pbs->cur
, afi->ia_sz, afi->af, &temp_address);/*解析子网地址*/
    if (ughmsg == NULL)
ughmsg = initaddr(id_pbs->cur + afi->ia_sz
    , afi->ia_sz, afi->af, &temp_mask);/*解析子网掩码*/
    if (ughmsg == NULL)
ughmsg = initsubnet(&temp_address, masktocount(&temp_mask)
    , '0', net);
    if (ughmsg == NULL && subnetisnone(net))
ughmsg = "contains only anyaddr";
    if (ughmsg != NULL)
    {
loglog(RC_LOG_SERIOUS, "%s ID payload %s bad subnet in Quick I1 (%s)"
    , which, idtypename, ughmsg);
/* XXX Could send notification back */
return FALSE;
    }
    DBG(DBG_PARSING | DBG_CONTROL,
{
    char temp_buff[SUBNETTOT_BUF];    subnettot(net, 0, temp_buff, sizeof(temp_buff));
    DBG_log("%s is subnet %s", which, temp_buff);
});
    break;
}case ID_IPV4_ADDR_RANGE:
case ID_IPV6_ADDR_RANGE:
{
    ip_address temp_address_from, temp_address_to;
    err_t ughmsg;    if (pbs_left(id_pbs) != 2 * afi->ia_sz)
    {
loglog(RC_LOG_SERIOUS, "%s ID payload %s wrong length in Quick I1"
    , which, idtypename);
/* XXX Could send notification back */
return FALSE;
    }/*解析子网地址*/
    ughmsg = initaddr(id_pbs->cur, afi->ia_sz, afi->af, &temp_address_from);
    if (ughmsg == NULL)/*解析子网掩码*/
ughmsg = initaddr(id_pbs->cur + afi->ia_sz
    , afi->ia_sz, afi->af, &temp_address_to);
    if (ughmsg != NULL)
    {
loglog(RC_LOG_SERIOUS, "%s ID payload %s malformed (%s) in Quick I1"
    , which, idtypename, ughmsg);
/* XXX Could send notification back */
return FALSE;
    }    ughmsg = rangetosubnet(&temp_address_from, &temp_address_to, net);
    if (ughmsg == NULL && subnetisnone(net))
ughmsg = "contains only anyaddr";
    if (ughmsg != NULL)
    {
char temp_buff1[ADDRTOT_BUF], temp_buff2[ADDRTOT_BUF];addrtot(&temp_address_from, 0, temp_buff1, sizeof(temp_buff1));
addrtot(&temp_address_to, 0, temp_buff2, sizeof(temp_buff2));
loglog(RC_LOG_SERIOUS, "%s ID payload in Quick I1, %s"
    " %s - %s unacceptable: %s"
    , which, idtypename, temp_buff1, temp_buff2, ughmsg);
return FALSE;
    }
    DBG(DBG_PARSING | DBG_CONTROL,
{
    char temp_buff[SUBNETTOT_BUF];    subnettot(net, 0, temp_buff, sizeof(temp_buff));
    DBG_log("%s is subnet %s (received as range)"
, which, temp_buff);
});
    break;
}
    }    /* set the port selector */
    setportof(htons(id->isaiid_port), &net->addr);    DBG(DBG_PARSING | DBG_CONTROL,
        DBG_log("%s protocol/port is %d/%d", which, id->isaiid_protoid, id->isaiid_port)
    )    return TRUE;
}

5.2 emit_subnet_id()

emit_subnet_id()函数的作用：

• 将隧道的保护子网地址转换为ID载荷内容，然后封装到报文中。

这个函数默认使用保护子网地址填充ID载荷（usehost===FALSE）。此函数与decode_net_id()共同完成保护子网地址的转换工作。

*填充的是隧道端口IP还是子网的信息?
*保护子网是如何协商的???
*/
static bool
emit_subnet_id(struct end *e
       , u_int8_t np
               , ip_address endpoint
       , u_int8_t protoid
       , u_int16_t port
       , pb_stream *outs)
{
    struct isakmp_ipsec_id id;
    pb_stream id_pbs;
    ip_address ta;
    unsigned char *tbp;
    size_t tal;
    const struct af_info *ai;
    bool usehost = FALSE;
    ip_subnet clientnet;    clientnet = e->client;    if(!e->has_client) {
        /* we propose the IP address of the interface that we are using. */
        /*
     * we could instead propose 0.0.0.0->255.255.255.255 and let the other
     * end narrow the TS, but if one wants that, it is easy to just specify
     * in the configuration file: rightsubnet=0.0.0.0/0.
     *
     * When there is NAT involved, we may really want a tunnel to the
     * address that this end point thinks it is.  That works only when
     * virtual_ip includes the IP involved.
     *
     */
        addrtosubnet(&endpoint, &clientnet);
    }    ai = aftoinfo(subnettypeof(&clientnet));
    passert(ai != NULL);    id.isaiid_np = np;
    id.isaiid_idtype = (usehost ? ai->id_addr : ai->id_subnet);/*确定使用主机ID还是子网ID*/
    id.isaiid_protoid = protoid;
    id.isaiid_port = port;    if (!out_struct(&id, &isakmp_ipsec_identification_desc, outs, &id_pbs))
return FALSE;    networkof(&clientnet, &ta);/*获取保护子网*/
    tal = addrbytesptr(&ta, &tbp);
    if (!out_raw(tbp, tal, &id_pbs, "client network"))/*填充保护子网信息*/
return FALSE;    if(!usehost)
    {
maskof(&clientnet, &ta);/*获取保护子网掩码*/
tal = addrbytesptr(&ta, &tbp);
if (!out_raw(tbp, tal, &id_pbs, "client mask"))/*填充保护子网掩码信息*/
    return FALSE;
    }    close_output_pbs(&id_pbs);
    return TRUE;
}

6. 小结

快速模式的第二个报文流程相对其他报文复杂了很多，尚有很多关键部分没有完全没有理解。每有会意，再做更新，如果有get到的，请分享下共同进步。