IKEv1 MainMode Cert 代码流程梳理

最新推荐文章于 2023-03-15 21:18:51 发布
最新推荐文章于 2023-03-15 21:18:51 发布
阅读量1.4k 收藏
点赞数
分类专栏： strongswan 文章标签： strongswan
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingyeping/article/details/50264575
版权

初始的配置如下：
Initiator： 
   
   

    
    

     
     config setup
    
    

    
    

     
      
    
    

    
    

     
     conn %default
    
    

    
    

     
     	ikelifetime=60m
    
    

    
    

     
     	keylife=20m
    
    

    
    

     
     	rekeymargin=3m
    
    

    
    

     
     	keyingtries=1
    
    

    
    

     
     	keyexchange=ikev1
    
    

    
    

     
      
    
    

    
    

     
     conn rw
    
    

    
    

     
     	left=PH_IP_MOON
    
    

    
    

     
     	leftcert=moonCert.pem
    
    

    
    

     
     	leftid=@moon.strongswan.org
    
    

    
    

     
     	leftsubnet=10.1.0.0/16
    
    

    
    

     
     	leftfirewall=yes
    
    

    
    

     
     #	right=%any
    
    

    
    

     
     	right=PH_IP_SUN
    
    

    
    

     
     	rightid=@sun.strongswan.org
    
    

    
    

     
     	rightsubnet=10.1.0.0/16
    
    

    
    

     
     	auto=add
Responder： 
   
   

    
    

     
     config setup
    
    

    
    

     
      
    
    

    
    

     
     conn %default
    
    

    
    

     
     	ikelifetime=60m
    
    

    
    

     
     	keylife=20m
    
    

    
    

     
     	rekeymargin=3m
    
    

    
    

     
     	keyingtries=1
    
    

    
    

     
     	keyexchange=ikev1
    
    

    
    

     
      
    
    

    
    

     
     conn home
    
    

    
    

     
     	left=PH_IP_SUN
    
    

    
    

     
     	leftcert=sunCert.pem
    
    

    
    

     
     	leftid=@sun.strongswan.org
    
    

    
    

     
             leftsubnet=10.1.0.0/16
    
    

    
    

     
     	leftfirewall=yes
    
    

    
    

     
     	right=PH_IP_MOON
    
    

    
    

     
     	rightid=@moon.strongswan.org
    
    

    
    

     
     	rightsubnet=10.1.0.0/16
    
    

    
    

     
     	auto=add
与证书认证相关的报文开始于第一条报文，主动方需要获取认证类型，在main_mode.c的build_i中会get_auth_mode，
最终或调用到credential_manager.c里的get_private，在这里，将会确定一次信任链moon->strongswanCA，这个时候
会把moon->CA，CA->CA的关系存到cert_cache.c中。

后面跳到第四条报文，由接收起方发出如下载荷：
接收方  KE No   CERTREQ NAT-D NAT-D -----> 发起方
接收方在isakmp_cert_pre.c的build_certreqs里，其代码如下： 
   
   

    
    

     
     /**
    
    

    
    

     
      * Build certificate requests
    
    

    
    

     
      */
    
    

    
    

     
     static void build_certreqs(private_isakmp_cert_pre_t *this, message_t *message)
    
    

    
    

     
     {
    
    

    
    

     
         enumerator_t *enumerator;
    
    

    
    

     
         ike_cfg_t *ike_cfg;
    
    

    
    

     
         peer_cfg_t *peer_cfg;
    
    

    
    

     
         certificate_t *cert;
    
    

    
    

     
         auth_cfg_t *auth;
    
    

    
    

     
      
    
    

    
    

     
         ike_cfg = this->ike_sa->get_ike_cfg(this->ike_sa);
    
    

    
    

     
         if (!ike_cfg->send_certreq(ike_cfg))
    
    

    
    

     
         {
    
    

    
    

     
             return;
    
    

    
    

     
         }
    
    

    
    

     
         /* check if we require a specific CA for that peer */
    
    

    
    

     
         peer_cfg = this->ike_sa->get_peer_cfg(this->ike_sa);
    
    

    
    

     
         if (peer_cfg)
    
    

    
    

     
         {   /*默认的配置里，我们没有指定新的CA，因此不会走到add_certreqs的流程 */
    
    

    
    

     
             enumerator = peer_cfg->create_auth_cfg_enumerator(peer_cfg, FALSE);
    
    

    
    

     
             if (enumerator->enumerate(enumerator, &auth))
    
    

    
    

     
             {
    
    

    
    

     
                 add_certreqs(this, auth, message);
    
    

    
    

     
             }
    
    

    
    

     
             enumerator->destroy(enumerator);
    
    

    
    

     
         }
    
    

    
    

     
         if (!message->get_payload(message, PLV1_CERTREQ))
    
    

    
    

     
         {
    
    

    
    

     
             /* otherwise add all trusted CA certificates */
    
    

    
    

     
             enumerator = lib->credmgr->create_cert_enumerator(lib->credmgr,
    
    

    
    

     
                                                     CERT_ANY, KEY_ANY, NULL, TRUE);
    
    

    
    

     
             while (enumerator->enumerate(enumerator, &cert))
    
    

    
    

     
             {   /* 遍历了lib->credmgr的sets链表，去找所有证书，在add_certreq里会判断，只会添加CA证书，并且加入的是证书的subject */
    
    

    
    

     
                 add_certreq(this, message, cert);
    
    

    
    

     
             }
    
    

    
    

     
             enumerator->destroy(enumerator);
    
    

    
    

     
         }
    
    

    
    

     
     }
然后打包消息发送出去。
发起方在收到消息后，需要解析这个报文，在isakmp_cert_pre.c中，调用process_certreqs进行处理 
   
   

    
    

     
     static void process_certreqs(private_isakmp_cert_pre_t *this, message_t *message)
    
    

    
    

     
     {
    
    

    
    

     
         enumerator_t *enumerator;
    
    

    
    

     
         payload_t *payload;
    
    

    
    

     
         auth_cfg_t *auth;
    
    

    
    

     
      
    
    

    
    

     
         auth = this->ike_sa->get_auth_cfg(this->ike_sa, TRUE);/* 注意，这里找到ike_sa->my_auth，注意，此时auth->entries里面的元素是空的 */
    
    

    
    

     
      
    
    

    
    

     
         enumerator = message->create_payload_enumerator(message);
    
    

    
    

     
         while (enumerator->enumerate(enumerator, &payload))
    
    

    
    

     
         {
    
    

    
    

     
             switch (payload->get_type(payload))
    
    

    
    

     
             {
    
    

    
    

     
                 case PLV1_CERTREQ:
    
    

    
    

     
                 {
    
    

    
    

     
                     certificate_t *cert;
    
    

    
    

     
      
    
    

    
    

     
                     this->ike_sa->set_condition(this->ike_sa,
    
    

    
    

     
                                                 COND_CERTREQ_SEEN, TRUE);
    
    

    
    

     
                     cert = find_certificate(this, (certreq_payload_t*)payload); /* 根据证书载荷找到CA证书 */
    
    

    
    

     
                     if (cert)
    
    

    
    

     
                     {   /* 找到了，那么把CA证书保存到ike_sa->my_auth->entries中 */
    
    

    
    

     
                         auth->add(auth, AUTH_RULE_CA_CERT, cert);
    
    

    
    

     
                     }
    
    

    
    

     
                     break;
    
    

    
    

     
                 }
    
    

    
    

     
                 default:
    
    

    
    

     
                     break;
    
    

    
    

     
             }
    
    

    
    

     
         }
    
    

    
    

     
         enumerator->destroy(enumerator);
    
    

    
    

     
     }
后面进入到主动方打包第五条报文的阶段
第五条报文 ID CERT SIG CERTREQ N(INITIAL_CONTACT) -->
同样的，主动方需要先build_certreqs，这里和第四条报文一样。后面是先构造sig载荷，然后再构造cert载荷。
填充SIG载荷在main_mode.c的build_i的流程中 
   
   

    
    

     
             case MM_KE:
    
    

    
    

     
             {
    
    

    
    

     
                 id_payload_t *id_payload;
    
    

    
    

     
                 identification_t *id;
    
    

    
    

     
      
    
    

    
    

     
                 id = this->ph1->get_id(this->ph1, this->peer_cfg, TRUE);
    
    

    
    

     
                 if (!id)
    
    

    
    

     
                 {
    
    

    
    

     
                     DBG1(DBG_CFG, "own identity not known");
    
    

    
    

     
                     return send_notify(this, INVALID_ID_INFORMATION);
    
    

    
    

     
                 }
    
    

    
    

     
                 this->ike_sa->set_my_id(this->ike_sa, id->clone(id));/* 保存自己的ID moon.strongswan.cn 到ike_sa->my_id中，之前my_id为空 */
    
    

    
    

     
                 id_payload = id_payload_create_from_identification(PLV1_ID, id);
    
    

    
    

     
                 message->add_payload(message, &id_payload->payload_interface);
    
    

    
    

     
      
    
    

    
    

     
                 if (!this->ph1->build_auth(this->ph1, this->method, message,    /* 构造SIG载荷 */
    
    

    
    

     
                                            id_payload->get_encoded(id_payload)))
    
    

    
    

     
                 {
    
    

    
    

     
                     return send_notify(this, AUTHENTICATION_FAILED);
    
    

    
    

     
                 }
    
    

    
    

     
      
    
    

    
    

     
                 add_initial_contact(this, message, id);
    
    

    
    

     
      
    
    

    
    

     
                 this->state = MM_AUTH;
    
    

    
    

     
                 return NEED_MORE;
    
    

    
    

     
             }
如上代码所示，调用phase1.c的build_auth构造SIG，最终调用到pubkey_v1_authenticator.c的build构造。
逻辑上，这里需要找到本地证书的私钥，对hash数据进行签名。因此build时需要先找到私钥，通过如下查找
    private = lib->credmgr->get_private(lib->credmgr, this->type, id, auth);
这里查找比较绕，跟进去看一下，调用的是credential_manager.c的get_private去找。
这里的入参type=KEY_RSA，auth是ike_sa->my_auth，id是moon_strongswan.cn
在get_private函数里，auth为真，这一次在创建trust_chain的时候，在匹配issued_by时，会使用之前的cache。
注意，创建完trust_chain后，会把本地证书和CA证书加到ike_sa->my_auth中。 找到private之后就做签名的处理。
签名成功后，会保存auth_cfg，ike_sa->my_auth中会有3个条目，两个是本地CA（相同的条目），一个是本地证书。
然后ike_sa->my_auths里会再存一份ike_sa->my_auth相同的auth_cfg

此后构造cert报文。这里使用my_auth中的本地证书构造报文。 
   
   

    
    

     
     METHOD(credential_manager_t, get_private, private_key_t*,
    
    

    
    

     
         private_credential_manager_t *this, key_type_t type, identification_t *id,
    
    

    
    

     
         auth_cfg_t *auth)
    
    

    
    

     
     {
    
    

    
    

     
         enumerator_t *enumerator;
    
    

    
    

     
         certificate_t *cert;
    
    

    
    

     
         private_key_t *private = NULL;
    
    

    
    

     
         auth_cfg_t *trustchain;
    
    

    
    

     
         auth_rule_t rule;
    
    

    
    

     
      
    
    

    
    

     
         /* check if this is a lookup by key ID, and do it if so */
    
    

    
    

     
         if (id && id->get_type(id) == ID_KEY_ID)    /* M_I_5里type为KEY_RSA，因此不会走到这 */
    
    

    
    

     
         {
    
    

    
    

     
             private = get_private_by_keyid(this, type, id);
    
    

    
    

     
             if (private)
    
    

    
    

     
             {
    
    

    
    

     
                 return private;
    
    

    
    

     
             }
    
    

    
    

     
         }
    
    

    
    

     
      
    
    

    
    

     
         if (auth)
    
    

    
    

     
         {    /* M_I_5里auth虽然不为空，首次来的时候，里面只有CA的证书 *//* 在M_I_1中，get_auth_method会走到这里 */
    
    

    
    

     
             /* try to find a trustchain with one of the configured subject certs */
    
    

    
    

     
             enumerator = auth->create_enumerator(auth);
    
    

    
    

     
             while (enumerator->enumerate(enumerator, &rule, &cert))
    
    

    
    

     
             {
    
    

    
    

     
                 if (rule == AUTH_RULE_SUBJECT_CERT)
    
    

    
    

     
                 {   /* get_auth_method里传下来的auth是配置里的auth，是有本地证书的，*/
    
    

    
    

     
                     private = get_private_by_cert(this, cert, type);
    
    

    
    

     
                     if (private)
    
    

    
    

     
                     {
    
    

    
    

     
                         trustchain = build_trustchain(this, cert, auth);
    
    

    
    

     
                         if (trustchain)
    
    

    
    

     
                         {
    
    

    
    

     
                             auth->merge(auth, trustchain, FALSE);
    
    

    
    

     
                             prefer_cert(auth, cert->get_ref(cert));
    
    

    
    

     
                             trustchain->destroy(trustchain);
    
    

    
    

     
                             break;
    
    

    
    

     
                         }
    
    

    
    

     
                         private->destroy(private);
    
    

    
    

     
                         private = NULL;
    
    

    
    

     
                     }
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
             enumerator->destroy(enumerator);
    
    

    
    

     
             if (private)
    
    

    
    

     
             {
    
    

    
    

     
                 return private;
    
    

    
    

     
             }
    
    

    
    

     
             /* M_I_5里，首次找也是没有的 */
    
    

    
    

     
             /* if none yielded a trustchain, enforce the first configured cert */
    
    

    
    

     
             cert = auth->get(auth, AUTH_RULE_SUBJECT_CERT);
    
    

    
    

     
             if (cert)
    
    

    
    

     
             {
    
    

    
    

     
                 private = get_private_by_cert(this, cert, type);
    
    

    
    

     
                 if (private)
    
    

    
    

     
                 {
    
    

    
    

     
                     trustchain = build_trustchain(this, cert, auth);
    
    

    
    

     
                     if (trustchain)
    
    

    
    

     
                     {
    
    

    
    

     
                         auth->merge(auth, trustchain, FALSE);
    
    

    
    

     
                         trustchain->destroy(trustchain);
    
    

    
    

     
                     }
    
    

    
    

     
                     return private;
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
      
    
    

    
    

     
             /* try to build a trust chain for each certificate found */
    
    

    
    

     
             enumerator = create_cert_enumerator(this, CERT_ANY, type, id, FALSE);
    
    

    
    

     
             while (enumerator->enumerate(enumerator, &cert))
    
    

    
    

     
             {   /* 通过ID找到本地证书 */
    
    

    
    

     
                 private = get_private_by_cert(this, cert, type);/* 找私钥 */
    
    

    
    

     
                 if (private)
    
    

    
    

     
                 {   /* 构造证书信任链 */
    
    

    
    

     
                     trustchain = build_trustchain(this, cert, auth);
    
    

    
    

     
                     if (trustchain)
    
    

    
    

     
                     {
    
    

    
    

     
                         auth->merge(auth, trustchain, FALSE);
    
    

    
    

     
                         trustchain->destroy(trustchain);
    
    

    
    

     
                         break;
    
    

    
    

     
                     }
    
    

    
    

     
                     private->destroy(private);
    
    

    
    

     
                     private = NULL;
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
             enumerator->destroy(enumerator);
    
    

    
    

     
         }
    
    

    
    

     
      
    
    

    
    

     
         /* if no valid trustchain was found, fall back to the first usable cert */
    
    

    
    

     
         if (!private)
    
    

    
    

     
         {
    
    

    
    

     
             enumerator = create_cert_enumerator(this, CERT_ANY, type, id, FALSE);
    
    

    
    

     
             while (enumerator->enumerate(enumerator, &cert))
    
    

    
    

     
             {
    
    

    
    

     
                 private = get_private_by_cert(this, cert, type);
    
    

    
    

     
                 if (private)
    
    

    
    

     
                 {
    
    

    
    

     
                     if (auth)
    
    

    
    

     
                     {
    
    

    
    

     
                         auth->add(auth, AUTH_RULE_SUBJECT_CERT, cert->get_ref(cert));
    
    

    
    

     
                     }
    
    

    
    

     
                     break;
    
    

    
    

     
                 }
    
    

    
    

     
             }
    
    

    
    

     
             enumerator->destroy(enumerator);
    
    

    
    

     
         }
    
    

    
    

     
         return private;
    
    

    
    

     
     }
    
    

   
   
    
    

     
     

      
      /**
     
     

     
     

      
       * find a private key of a given certificate
     
     

     
     

      
       */
     
     

     
     

      
      static private_key_t *get_private_by_cert(private_credential_manager_t *this,
     
     

     
     

      
                                                certificate_t *cert, key_type_t type)
     
     

     
     

      
      {
     
     

     
     

      
          private_key_t *private = NULL;
     
     

     
     

      
          identification_t *keyid;
     
     

     
     

      
          chunk_t chunk;
     
     

     
     

      
          public_key_t *public;
     
     

     
     

      
       
     
     

     
     

      
          public = cert->get_public_key(cert);
     
     

     
     

      
          if (public)
     
     

     
     

      
          {   /* 这里的私钥，是通过指纹匹配的，指纹之前配置时就生成好的 */
     
     

     
     

      
              if (public->get_fingerprint(public, KEYID_PUBKEY_SHA1, &chunk))
     
     

     
     

      
              {
     
     

     
     

      
                  keyid = identification_create_from_encoding(ID_KEY_ID, chunk);
     
     

     
     

      
                  private = get_private_by_keyid(this, type, keyid);
     
     

     
     

      
                  keyid->destroy(keyid);
     
     

     
     

      
              }
     
     

     
     

      
              public->destroy(public);
     
     

     
     

      
          }
     
     

     
     

      
          return private;
     
     

     
     

      
      }
     
     

    
    
     
     

      
      

       
       /**
      
      

      
      

       
        * build a trustchain from subject up to a trust anchor in trusted
      
      

      
      

       
        */
      
      

      
      

       
       static auth_cfg_t *build_trustchain(private_credential_manager_t *this,
      
      

      
      

       
                                            certificate_t *subject, auth_cfg_t *auth)
      
      

      
      

       
       {
      
      

      
      

       
           certificate_t *issuer, *current;
      
      

      
      

       
           auth_cfg_t *trustchain;
      
      

      
      

       
           int pathlen = 0;
      
      

      
      

       
           bool has_anchor;
      
      

      
      

       
        
      
      

      
      

       
           trustchain = auth_cfg_create();
      
      

      
      

       
           has_anchor = auth->get(auth, AUTH_RULE_CA_CERT) != NULL; /* ike_sa的auth传进来的时候已经有本地CA了，配置auth传下来没有 */
      
      

      
      

       
           current = subject->get_ref(subject);
      
      

      
      

       
           while (TRUE)
      
      

      
      

       
           {   /* auth_contans_cacert是要判断auth里是否有CA证书，且CA证书和currrent是同一个证书 */
      
      

      
      

       
               if (auth_contains_cacert(auth, current))    /* 第一次current为要认证的证书，这里为假，第二次为第一次的签发者，以此类推 */
      
      

      
      

       
               {
      
      

      
      

       
                   trustchain->add(trustchain, AUTH_RULE_CA_CERT, current);
      
      

      
      

       
                   return trustchain;
      
      

      
      

       
               }
      
      

      
      

       
               if (subject == current)
      
      

      
      

       
               {   /* 第一次是相等的 ，因此会把本地证书加到信任链中 */
      
      

      
      

       
                   trustchain->add(trustchain, AUTH_RULE_SUBJECT_CERT, current);
      
      

      
      

       
               }
      
      

      
      

       
               else
      
      

      
      

       
               {
      
      

      
      

       
                   if (!has_anchor && issued_by(this, current, current, NULL))/* 如果没有指定根CA，那么此时又自认证成功，那么认为成功 */
      
      

      
      

       
                   {    /* If no trust anchor specified, accept any CA */
      
      

      
      

       
                       trustchain->add(trustchain, AUTH_RULE_CA_CERT, current);
      
      

      
      

       
                       return trustchain;
      
      

      
      

       
                   }
      
      

      
      

       
                   trustchain->add(trustchain, AUTH_RULE_IM_CERT, current);
      
      

      
      

       
               }
      
      

      
      

       
               if (pathlen++ > MAX_TRUST_PATH_LEN) /* 证书链的层次 */
      
      

      
      

       
               {
      
      

      
      

       
                   break;
      
      

      
      

       
               }
      
      

      
      

       
               issuer = get_issuer_cert(this, current, FALSE, NULL);/* 找本证书的签发者 */
      
      

      
      

       
               if (!issuer)
      
      

      
      

       
               {
      
      

      
      

       
                   if (!has_anchor)
      
      

      
      

       
                   {    /* If no trust anchor specified, accept incomplete chains */
      
      

      
      

       
                       return trustchain;
      
      

      
      

       
                   }
      
      

      
      

       
                   break;
      
      

      
      

       
               }
      
      

      
      

       
               if (has_anchor && issuer->equals(issuer, current))/* 如果指定了根CA，去比较最终的签发者 */
      
      

      
      

       
               {
      
      

      
      

       
                   issuer->destroy(issuer);
      
      

      
      

       
                   break;
      
      

      
      

       
               }
      
      

      
      

       
               current = issuer;
      
      

      
      

       
           }
      
      

      
      

       
           trustchain->destroy(trustchain);
      
      

      
      

       
           return NULL;
      
      

      
      

       
       }

接收方收到第五条报文后，先process_certreqs，把找到的本地CA存放到ike_sa->my_auth中。
然后process_certs， 从载荷中取出证书，注意，这时候我们只有一个证书，没有测试过证书链的情况。把证书取出来后，
放到了ike_sa->other_auth中。

其后在main_mode.c的process_r里去验证SIG载荷。 
   
   

    
    

     
             case MM_KE:
    
    

    
    

     
             {
    
    

    
    

     
                 id_payload_t *id_payload;
    
    

    
    

     
                 identification_t *id;
    
    

    
    

     
      
    
    

    
    

     
                 id_payload = (id_payload_t*)message->get_payload(message, PLV1_ID);
    
    

    
    

     
                 if (!id_payload)
    
    

    
    

     
                 {
    
    

    
    

     
                     DBG1(DBG_IKE, "IDii payload missing");
    
    

    
    

     
                     return send_notify(this, INVALID_PAYLOAD_TYPE);
    
    

    
    

     
                 }
    
    

    
    

     
                 id = id_payload->get_identification(id_payload);
    
    

    
    

     
                 this->ike_sa->set_other_id(this->ike_sa, id);
    
    

    
    

     
      
    
    

    
    

     
                 while (TRUE)
    
    

    
    

     
                 {
    
    

    
    

     
                     DESTROY_IF(this->peer_cfg);
    
    

    
    

     
                     this->peer_cfg = this->ph1->select_config(this->ph1,
    
    

    
    

     
                                                         this->method, FALSE, id);
    
    

    
    

     
                     if (!this->peer_cfg)
    
    

    
    

     
                     {
    
    

    
    

     
                         return send_notify(this, AUTHENTICATION_FAILED);
    
    

    
    

     
                     }
    
    

    
    

     
                     this->ike_sa->set_peer_cfg(this->ike_sa, this->peer_cfg);
    
    

    
    

     
      
    
    

    
    

     
                     if (this->ph1->verify_auth(this->ph1, this->method, message,
    
    

    
    

     
                                                id_payload->get_encoded(id_payload)))
    
    

    
    

     
                     {
    
    

    
    

     
                         break;
    
    

    
    

     
                     }
    
    

    
    

     
                 }
    
    

    
    

     
      
    
    

    
    

     
                 if (!charon->bus->authorize(charon->bus, FALSE))
    
    

    
    

     
                 {
    
    

    
    

     
                     DBG1(DBG_IKE, "Main Mode authorization hook forbids IKE_SA, "
    
    

    
    

     
                          "cancelling");
    
    

    
    

     
                     return send_notify(this, AUTHENTICATION_FAILED);
    
    

    
    

     
                 }
    
    

    
    

     
      
    
    

    
    

     
                 this->state = MM_AUTH;
    
    

    
    

     
                 if (has_notify_errors(this, message))
    
    

    
    

     
                 {
    
    

    
    

     
                     return FAILED;
    
    

    
    

     
                 }
    
    

    
    

     
                 return NEED_MORE;
    
    

    
    

     
             }
下面的逻辑就是要认证对方发送的SIG载荷。在pubkey_v1_authenticator.c：process中，
需要先获取证书的pubkey，注意，调用如下： 
   
   

    
    

     
         sig = sig_payload->get_hash(sig_payload);
    
    

    
    

     
         auth = this->ike_sa->get_auth_cfg(this->ike_sa, FALSE);
    
    

    
    

     
         enumerator = lib->credmgr->create_public_enumerator(lib->credmgr, this->type,
    
    

    
    

     
                                                             id, auth);
    
    

    
    

     
         while (enumerator->enumerate(enumerator, &public, &current_auth))
    
    

    
    

     
         {
    
    

    
    

     
             if (public->verify(public, scheme, hash, sig))
    
    

    
    

     
             {
    
    

    
    

     
                 DBG1(DBG_IKE, "authentication of '%Y' with %N successful",
    
    

    
    

     
                      id, key_type_names, this->type);
    
    

    
    

     
                 status = SUCCESS;
    
    

    
    

     
                 auth->merge(auth, current_auth, FALSE);
    
    

    
    

     
                 auth->add(auth, AUTH_RULE_AUTH_CLASS, AUTH_CLASS_PUBKEY);
    
    

    
    

     
                 break;
    
    

    
    

     
             }
    
    

    
    

     
             else
    
    

    
    

     
             {
    
    

    
    

     
                 DBG1(DBG_IKE, "signature validation failed, looking for another key");
    
    

    
    

     
                 status = FAILED;
    
    

    
    

     
             }
    
    

    
    

     
         }
    
    

    
    

     
         enumerator->destroy(enumerator);
这里需要注意的是credential_manager.c的create_public_enumerator函数，这里创建的enumerator是比较怪的。
说一下逻辑：
先调用public_enumerate 
                ---> trusted_enumerate 
                        第一次，this->candidates为空，创建一个candidates，这个实际是一个enumerator，遍历当前
credential_manager里的sets里的cert。然后找已经信任的证书中是否有这个证书，第一次，自然没有。
this->pretrusted为空。然后遍历candidates。下面分析一下这个candidates的enumerator
从最外层看，candidates是一个nested的enumerator，即它有两层遍历，先遍历外层，再遍历内层。
那么他的外层是什么呢？外层通过create_sets_enumerator来创建。是一个sets的遍历器，看他的遍历函数为
sets_enumerate，这里面又遍历，先遍历exclusive，然后遍历global，再遍历local。在当前的调用中，他的
实际工作就是，先遍历credential_manager下的sets，取出每一个set。
内层的遍历器是通过create_cert构造的，它调用的set的构造器创建，这个enumerator实际最终调用了各个set的
构造器，比如credential_manager.c的sets各自的构造器，又或者auth_wrapper的构造器
如果内部遍历成功了，那么取出对应的数据
给上层调用者，如果不成功，再遍历之前的auth_wrapper构造的local_set，再进行遍历。实际遍历过程中，真正
匹配到的数据在local_set中。
在这个时候，最终从auth_cfg（即ike_sa->other_auth）中获取到了对方的证书。然后开始调用verify_trust_chain
去验证一下这个证书是否可信。
先找到证书的颁发者，由于我们的不是证书链，因此直接找到上级CA，注意，这里在找颁发者时，会保存对应关系到
cert_cach中。然后调用check_certificate来检查证书 是否是有效的，先检查证书和签发者两者的签发日期。
这里调用了validators，此时只有两个，一个是 constraints_validator_t，另一个是 revocation_validator_t，
两个都没有check_lifetime的回调，因此继续往下。 然后又继续使用validator验证，使用的先是revocation_validator，
validate：先oscp又crl，都无法验证，返回true。
然后constraint，这个不太懂，需要再找一下，似乎是证书的一些限制。后面就是用pubkey去verify SIG。
然后在ike_sa->other_auth里填了一堆东西：
$63 = {type = AUTH_RULE_AUTH_CLASS, value = 0x1}
$52 = {type = AUTH_HELPER_SUBJECT_CERT, value = 0x7f2d40016f10}
$53 = {type = AUTH_RULE_RSA_STRENGTH, value = 0x800}
$54 = {type = AUTH_RULE_RSA_STRENGTH, value = 0x800}
$55 = {type = AUTH_RULE_SUBJECT_CERT, value = 0x7f2d40016f10}
$56 = {type = AUTH_RULE_CA_CERT, value = 0x19d5340}
$57 = {type = AUTH_RULE_SIGNATURE_SCHEME, value = 0x5}
$58 = {type = AUTH_RULE_OCSP_VALIDATION, value = 0x1}
$59 = {type = AUTH_RULE_CRL_VALIDATION, value = 0x3}
出去check_constraints，这里又向other_auth里插入了一个， type = AUTH_RULE_IDENTITY, value = 0x7f2d4000bae0
后面拿配置的对方的auth和生成的ike_sa->other_auth进行比较。配置的里面两个条目AUTH_RULE_AUTH_CLASS 0x1，
AUTH_RULE_AUTH_IDENTITY，value是对方的id，两个匹配都是一样的，认为通过，然后save_auth_cfg。
然后把ike_sa->other_auth里的所有东西merge到一个新的auth里，放在了ike_sa->other_auths里。

后面开始构造第六条报文，需要创建SIG和CERT载荷
和发送方一样，不再描述。
发起方收到第六条报文后，验证SIG，也是类似。

















xingyeping
关注
专栏目录
IPSec之IKEv1详解
sgslwms的博客
09-06 8197
该模式使用IKEv1协商阶段1中生成的密钥对ISAKMP消息的完整性和身份进行验证，并对ISAKMP消息进行加密，故保证了交换的安全性。IPSec SA数据传输需要的加密、验证密钥由第一阶段产生的密钥、SPI、协议等参数衍生得出，以保证每个IPSec SA都有自己独一无二的密钥。SKEYID_d = prf(SKEYID, K | Ci | Cr | 0) -----------推导密钥，衍生密钥。KE和第一阶段中的KE的目的是一样的，使用DH算法，计算出一个对公共的密钥作为隧道所用的加密密钥。
IPSec ×××中主模式（main mode）和积极模式（aggressive mode）的区别
weixin_34357928的博客
08-27 3388
对于IPsec 中IKE 协商的第一阶段，可以有主模式和积极模式两种协商模式选择，这取决于使用的场合，通常来讲，默认的时候都是用的主模式，如在Cisco设备中使用命令行进行预共享密钥的配置时，如果不指定为aggressive-mode的时候，就默认为主模式。但是不是所有的场合都适合使用主模式，比如对于对端的链接无法使用固定ip地址来确定时（如adsl），只能使用域名来定义，这个时候，主模式就不能用...
IKEv2-开源
05-02
该项目旨在全面实施RFC4306和相关的RFC。 它是作为守护进程执行的，就像针对类Unix操作系统的此类软件的自定义设置一样。 守护程序的主要目标是Linux环境，特别是Fedora Core 5。
IKEv1 主模式证书方法协商的载荷交互流程
xingyeping的博客
12-08 1935
INITIATOR                                                         RESPONDER SA V-xauth V-dpd V-nat-t V-nat-t-ike-02                                                                          SA V-xa
IKEV1协商过程及配置简介.docx
最新发布
04-27
### IKEv1协商过程及配置详解 #### 一、IPSec与IKE协议简介 ##### 1.1 IPSec概述 IPSec（Internet Protocol Security）是一种用于保障互联网通信安全的协议框架，它通过加密和认证机制确保数据包在传输过程中不被...
IKEV1
Hulk
03-15 1418
介绍ipsec IKE流程
IKEv2-rw-cert2.pcap
10-28
strongswan使用linux内核的af_alg加密接口配置，IKEv2协议交互报文。
IKEv1&IKEv2; Between Cisco IOS and strongSwan
05-09
介绍如何配置Cisco的IPSec模块和StrongSwan连接。英文，但是很简单。主要是配置示例很清晰。
Cisco IOS Internet Key Exchange version 1 (IKEv1) Vulnerability and Fix
Cyber Security Memo
12-09 246
Cisco IKEv1 is still popular in VPN configuration. Most of my vpn configuration is based on IKE v1 although there are more demands for v2. I had a post “Cisco Router IKE v2 Site to Site IPSec VPN Co...
ike-website：官方IKE文档
02-26
ike网站 官方IKE文档 如何建立： 从下载Hugo并将其添加到您的$ PATH中 克隆ilkilabs / ike网站项目 光盘ike-webste 在IKE-WEBSITE文件上添加 本地测试：雨果服务器-D 将您的更改推送到IKE-WEBSITE
IPSec之IKEv1协议详解
热门推荐
曹世宏的博客
04-20 4万+
IKE简介 安全联盟SA： 定义： 安全联盟是要建立IPSec 隧道的通信双方对隧道参数的约定，包括隧道两端的IP地址、隧道采用的验证方式、验证算法、验证密钥、加密算法、共享密钥以及生命周期等一系列参数。 SA由三元组来唯一标识，这个三元组包括安全参数索引SPI（Security Parameter Index）、目的IP地址和使用的安全协议号（AH或ESP）。其中，SPI是为唯一标识SA而生成的...
pluto实现分析(1)——前言、IKEv1概述、源文件概述
bytxl的专栏
09-25 2748
本文档的Copyleft归yfydz所有，使用GPL发布，可以自由拷贝，转载，转载时请保持文档的完整性，严禁用于任何商业用途。 msn: yfydz_no1@hotmail.com 来源：http://yfydz.cublog.cn 1. 前言 pluto是著名的VPN开源项目freeswan及其后续项目中的一个重要组成部分，实现了IKEv1(RFC2409)，原始的fre
山石网科-Hillstone-IPsec V_P_N常见故障debug排错心得终结版
weixin_34410662的博客
06-04 2701
嗨，各位好。相信各位过来点开的时候会鄙视一句“这厮，又来搞山石了”，哈哈没错，这次确实又来了，不过这次带了点排错的心得过来，希望给未来在常见的配置过程当中，不知道怎么排错时候有些帮助。说句真心话，山石（hillstone）确实挺好用的，不行你可以试试！！好了，废话少说。直接上菜ipsec的拓扑图，我临时画了一个，目的希望各位能有图看到，不然各位心里冒出千万个草泥马“NO pi...
IKEv2使用DNSSEC的IPSECKEY资源记录获取公钥的认证流程
redwingz的博客
01-10 1316
以下根据strongswan代码中的testing/tests/ikev2/net2net-dnssec/中的测试环境，来看一下IKEv2协议在协商时不交换证书，而是通过DNSSEC获取对端公钥的认证流程。拓扑结构如下： 拓扑图中使用到的设备包括：虚拟网关moon和sun网关。 网关配置 moon的配置文件：/etc/ipsec.conf，内容如下。注意此处的leftsigkey字段，在stro...
IKEv1协商安全联盟的过程
遇见你是我最美丽的意外
06-24 5608
IKEv1协商安全联盟的过程 采用IKEv1协商安全联盟主要分为两个阶段： 第一阶段，通信双方协商和建立IKE协议本身使用的安全通道，即建立一个IKE SA； 第二阶段，利用第一阶段已通过认证和安全保护的安全通道，建立一对用于数据安全传输的IPSec安全联盟。 1. IKEv1协商阶段1 IKEv1协商阶段1的目的是建立IKE SA。IKE SA建立后对等体间的所有ISAKMP消息都将通过加密和验证，这条安全通道可以保证IKEv1第二阶段的协商能够安全进行。 IKEv1协商阶段1支持两种协商模式
ISAKMP/IKE阶段1连接
weixin_33748818的博客
11-17 2609
(一)阶段1策略 1、启动ISAKMP(默认是开启的) R1(config)#crypto isakmp enable 2、建立策略(保护阶段1--管理连接) R1(config)#crypto isakmp policy ? <1-10000> Priority of protection suite R1(config-isakmp)#...
实现 iSCSI Initiator 的两种方法
TL的专栏
02-22 1217
实现 iSCSI Initiator 的两种方法 来源：ChinaItLab　时间：2006-9-26　保存本文　作者：佚名　收藏本站     首先我们要了解iSCSI架构中的角色与专词，iSCSI 的储存设备称为iSCSITarget（或称iSCSI Target Device），例如iSCSI磁盘阵列柜
ikev1和ikev2区别
03-09
IKEv1和IKEv2是两种不同版本的Internet＊＊＊中进行安全的密钥交换和身份验证。它们之间的主要区别如下： 1. 安全性：IKEv2相对于IKEv1提供了更高的安全性。它支持更强大的加密算法和认证方法，并提供了更好的防御机制来抵御各种攻击，如重放攻击和中间人攻击。 2. 连接建立速度：IKEv2相对于IKEv1具有更快的连接建立速度。它使用了更高效的协议交换和状态机，减少了握手过程中的往返次数，从而提高了连接建立的效率。 3. 移动性支持：IKEv2在移动性支持方面更加强大。它能够在网络切换或IP地址变化时快速重新建立连接，而无需重新进行完整的握手过程。这使得它在移动设备和移动网络环境下更加适用。 4. NAT穿越：IKEv2相对于IKEv1更好地支持NAT穿越。它使用了更灵活的消息格式和协商机制，可以更好地处理NAT设备引入的地址转换问题，从而提供更好的兼容性和可靠性。 5. 可扩展性：IKEv2相对于IKEv1具有更好的可扩展性。它支持动态加载和协商新的扩展功能，可以根据需要灵活地添加新的加密算法、认证方法和其他安全机制。＊＊＊ IKEv2如何提高连接建立速度？ 4. 为什么IKEv2在移动性支持方面更强大？ 5. NAT穿越是什么意思？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值