Home | History | Annotate | Download | only in test
      1 ##############################
      2 % PPTP Related regression tests
      3 ##############################
      4 
      5 + GRE Tests
      6 
      7 = Test IP/GRE v0 decoding
      8 ~ gre ip
      9 
     10 data = hex_bytes('45c00064000f0000ff2f1647c0a80c01c0a8170300000800')
     11 pkt = IP(data)
     12 assert GRE in pkt
     13 gre = pkt[GRE]
     14 assert gre.chksum_present == 0
     15 assert gre.routing_present == 0
     16 assert gre.key_present == 0
     17 assert gre.seqnum_present == 0
     18 assert gre.strict_route_source == 0
     19 assert gre.recursion_control == 0
     20 assert gre.flags == 0
     21 assert gre.version == 0
     22 assert gre.proto == 0x800
     23 
     24 = Test IP/GRE v1 decoding with PPP LCP
     25 ~ gre ip pptp ppp lcp
     26 
     27 data = hex_bytes('4500003c18324000402f0e5a0a0000020a0000063001880b001c9bf500000000ff03'\
     28        'c021010100180206000000000304c2270506fbb8831007020802')
     29 pkt = IP(data)
     30 assert GRE_PPTP in pkt
     31 gre_pptp = pkt[GRE_PPTP]
     32 assert gre_pptp.chksum_present == 0
     33 assert gre_pptp.routing_present == 0
     34 assert gre_pptp.key_present == 1
     35 assert gre_pptp.seqnum_present == 1
     36 assert gre_pptp.strict_route_source == 0
     37 assert gre_pptp.recursion_control == 0
     38 assert gre_pptp.acknum_present == 0
     39 assert gre_pptp.flags == 0
     40 assert gre_pptp.version == 1
     41 assert gre_pptp.proto == 0x880b
     42 assert gre_pptp.payload_len == 28
     43 assert gre_pptp.call_id == 39925
     44 assert gre_pptp.seqence_number == 0x0
     45 
     46 assert HDLC in pkt
     47 assert PPP in pkt
     48 assert PPP_LCP_Configure in pkt
     49 
     50 = Test IP/GRE v1 encoding/decoding with PPP LCP Echo
     51 ~ gre ip pptp ppp hdlc lcp lcp_echo
     52 
     53 pkt = IP(src='192.168.0.1', dst='192.168.0.2') /\
     54       GRE_PPTP(seqnum_present=1, acknum_present=1, seqence_number=47, ack_number=42) /\
     55       HDLC() / PPP() / PPP_LCP_Echo(id=42, magic_number=4242, data='abcdef')
     56 pkt_data = raw(pkt)
     57 pkt_data_ref = hex_bytes('4500003600010000402ff944c0a80001c0a800023081880b001200000000002f000000'\
     58                          '2aff03c021092a000e00001092616263646566')
     59 assert (pkt_data == pkt_data_ref)
     60 pkt_decoded = IP(pkt_data_ref)
     61 assert IP in pkt
     62 assert GRE_PPTP in pkt
     63 assert HDLC in pkt
     64 assert PPP in pkt
     65 assert PPP_LCP_Echo in pkt
     66 
     67 assert pkt[IP].proto == 47
     68 assert pkt[GRE_PPTP].chksum_present == 0
     69 assert pkt[GRE_PPTP].routing_present == 0
     70 assert pkt[GRE_PPTP].key_present == 1
     71 assert pkt[GRE_PPTP].seqnum_present == 1
     72 assert pkt[GRE_PPTP].acknum_present == 1
     73 assert pkt[GRE_PPTP].seqence_number == 47
     74 assert pkt[GRE_PPTP].ack_number == 42
     75 assert pkt[PPP].proto == 0xc021
     76 assert pkt[PPP_LCP_Echo].code == 9
     77 assert pkt[PPP_LCP_Echo].id == 42
     78 assert pkt[PPP_LCP_Echo].magic_number == 4242
     79 assert pkt[PPP_LCP_Echo].data == b'abcdef'
     80 
     81 + PPP LCP Tests
     82 = Test LCP Echo Request / Reply
     83 ~ ppp lcp lcp_echo
     84 
     85 lcp_echo_request_data = hex_bytes('c021090700080000002a')
     86 lcp_echo_reply_data = raw(PPP()/PPP_LCP_Echo(code=10, id=7, magic_number=77, data='defgh'))
     87 
     88 lcp_echo_request_pkt = PPP(lcp_echo_request_data)
     89 lcp_echo_reply_pkt = PPP(lcp_echo_reply_data)
     90 
     91 assert lcp_echo_reply_pkt.answers(lcp_echo_request_pkt)
     92 assert not lcp_echo_request_pkt.answers(lcp_echo_reply_pkt)
     93 
     94 lcp_echo_non_reply_data = raw(PPP()/PPP_LCP_Echo(code=10, id=3, magic_number=77))
     95 lcp_echo_non_reply_pkt = PPP(lcp_echo_non_reply_data)
     96 
     97 assert not lcp_echo_non_reply_pkt.answers(lcp_echo_request_pkt)
     98 
     99 lcp_echo_non_reply_data = raw(PPP()/PPP_LCP_Echo(id=7, magic_number=42))
    100 lcp_echo_non_reply_pkt = PPP(lcp_echo_non_reply_data)
    101 
    102 assert not lcp_echo_non_reply_pkt.answers(lcp_echo_request_pkt)
    103 
    104 = Test LCP Configure Request
    105 ~ ppp lcp lcp_configure magic_number
    106 
    107 conf_req = PPP() / PPP_LCP_Configure(id=42, options=[PPP_LCP_Magic_Number_Option(magic_number=4242)])
    108 conf_req_ref_data = hex_bytes('c021012a000a050600001092')
    109 
    110 assert raw(conf_req) == conf_req_ref_data
    111 
    112 conf_req_pkt = PPP(conf_req_ref_data)
    113 
    114 assert PPP_LCP_Configure in conf_req_pkt
    115 assert conf_req_pkt[PPP_LCP_Configure].code == 1
    116 assert conf_req_pkt[PPP_LCP_Configure].id == 42
    117 assert len(conf_req_pkt[PPP_LCP_Configure].options) == 1
    118 assert isinstance(conf_req_pkt[PPP_LCP_Configure].options[0], PPP_LCP_Magic_Number_Option)
    119 assert conf_req_pkt[PPP_LCP_Configure].options[0].magic_number == 4242
    120 
    121 = Test LCP Configure Ack
    122 ~ ppp lcp lcp_configure lcp_configure_ack
    123 
    124 conf_ack = PPP() / PPP_LCP_Configure(code='Configure-Ack', id=42,
    125                                      options=[PPP_LCP_Magic_Number_Option(magic_number=4242)])
    126 conf_ack_ref_data = hex_bytes('c021022a000a050600001092')
    127 
    128 assert (raw(conf_ack) == conf_ack_ref_data)
    129 
    130 conf_ack_pkt = PPP(conf_ack_ref_data)
    131 
    132 assert PPP_LCP_Configure in conf_ack_pkt
    133 assert conf_ack_pkt[PPP_LCP_Configure].code == 2
    134 assert conf_ack_pkt[PPP_LCP_Configure].id == 42
    135 assert len(conf_ack_pkt[PPP_LCP_Configure].options) == 1
    136 assert isinstance(conf_ack_pkt[PPP_LCP_Configure].options[0], PPP_LCP_Magic_Number_Option)
    137 assert conf_ack_pkt[PPP_LCP_Configure].options[0].magic_number == 4242
    138 
    139 conf_req_pkt = PPP(hex_bytes('c021012a000a050600001092'))
    140 
    141 assert conf_ack_pkt.answers(conf_req_pkt)
    142 assert not conf_req_pkt.answers(conf_ack_pkt)
    143 
    144 = Test LCP Configure Nak
    145 ~ ppp lcp lcp_configure lcp_configure_nak lcp_mru_option lcp_accm_option
    146 
    147 conf_nak = PPP() / PPP_LCP_Configure(code='Configure-Nak', id=42,
    148                                      options=[PPP_LCP_MRU_Option(), PPP_LCP_ACCM_Option(accm=0xffff0000)])
    149 conf_nak_ref_data = hex_bytes('c021032a000e010405dc0206ffff0000')
    150 
    151 assert(raw(conf_nak) == conf_nak_ref_data)
    152 
    153 conf_nak_pkt = PPP(conf_nak_ref_data)
    154 
    155 assert PPP_LCP_Configure in conf_nak_pkt
    156 assert conf_nak_pkt[PPP_LCP_Configure].code == 3
    157 assert conf_nak_pkt[PPP_LCP_Configure].id == 42
    158 assert len(conf_nak_pkt[PPP_LCP_Configure].options) == 2
    159 assert isinstance(conf_nak_pkt[PPP_LCP_Configure].options[0], PPP_LCP_MRU_Option)
    160 assert conf_nak_pkt[PPP_LCP_Configure].options[0].max_recv_unit == 1500
    161 assert isinstance(conf_nak_pkt[PPP_LCP_Configure].options[1], PPP_LCP_ACCM_Option)
    162 assert conf_nak_pkt[PPP_LCP_Configure].options[1].accm == 0xffff0000
    163 
    164 conf_req_pkt = PPP(hex_bytes('c021012a000e010405dc0206ffff0000'))
    165 
    166 assert conf_nak_pkt.answers(conf_req_pkt)
    167 assert not conf_req_pkt.answers(conf_nak_pkt)
    168 
    169 = Test LCP Configure Reject
    170 ~ ppp lcp lcp_configure lcp_configure_reject
    171 
    172 conf_reject = PPP() / PPP_LCP_Configure(code='Configure-Reject', id=42,
    173                                         options=[PPP_LCP_Callback_Option(operation='Location identifier',
    174                                                                          message='test')])
    175 conf_reject_ref_data = hex_bytes('c021042a000b0d070274657374')
    176 
    177 assert(raw(conf_reject) == conf_reject_ref_data)
    178 
    179 conf_reject_pkt = PPP(conf_reject_ref_data)
    180 
    181 assert PPP_LCP_Configure in conf_reject_pkt
    182 assert conf_reject_pkt[PPP_LCP_Configure].code == 4
    183 assert conf_reject_pkt[PPP_LCP_Configure].id == 42
    184 assert len(conf_reject_pkt[PPP_LCP_Configure].options) == 1
    185 assert isinstance(conf_reject_pkt[PPP_LCP_Configure].options[0], PPP_LCP_Callback_Option)
    186 assert conf_reject_pkt[PPP_LCP_Configure].options[0].operation == 2
    187 assert conf_reject_pkt[PPP_LCP_Configure].options[0].message == b'test'
    188 
    189 conf_req_pkt = PPP(hex_bytes('c021012a000b0d070274657374'))
    190 
    191 assert conf_reject_pkt.answers(conf_req_pkt)
    192 assert not conf_req_pkt.answers(conf_reject_pkt)
    193 
    194 = Test LCP Configure options
    195 ~ ppp lcp lcp_configure
    196 
    197 conf_req = PPP() / PPP_LCP_Configure(id=42, options=[PPP_LCP_MRU_Option(max_recv_unit=5000),
    198                                                      PPP_LCP_ACCM_Option(accm=0xf0f0f0f0),
    199                                                      PPP_LCP_Auth_Protocol_Option(),
    200                                                      PPP_LCP_Quality_Protocol_Option(data='test'),
    201                                                      PPP_LCP_Magic_Number_Option(magic_number=4242),
    202                                                      PPP_LCP_Callback_Option(operation='Distinguished name',message='test')])
    203 conf_req_ref_data = hex_bytes('c021012a0027010413880206f0f0f0f00304c0230408c025746573740506000010920d070474657374')
    204 
    205 assert(raw(conf_req) == conf_req_ref_data)
    206 
    207 conf_req_pkt = PPP(conf_req_ref_data)
    208 
    209 assert PPP_LCP_Configure in conf_req_pkt
    210 options = conf_req_pkt[PPP_LCP_Configure].options
    211 assert len(options) == 6
    212 assert isinstance(options[0], PPP_LCP_MRU_Option)
    213 assert options[0].max_recv_unit == 5000
    214 assert isinstance(options[1], PPP_LCP_ACCM_Option)
    215 assert options[1].accm == 0xf0f0f0f0
    216 assert isinstance(options[2], PPP_LCP_Auth_Protocol_Option)
    217 assert options[2].auth_protocol == 0xc023
    218 assert isinstance(options[3], PPP_LCP_Quality_Protocol_Option)
    219 assert options[3].quality_protocol == 0xc025
    220 assert options[3].data == b'test'
    221 assert isinstance(options[4], PPP_LCP_Magic_Number_Option)
    222 assert options[4].magic_number == 4242
    223 assert isinstance(options[5], PPP_LCP_Callback_Option)
    224 assert options[5].operation == 4
    225 assert options[5].message == b'test'
    226 
    227 = Test LCP Auth option
    228 ~ ppp lcp lcp_configure
    229 
    230 pap = PPP_LCP_Auth_Protocol_Option()
    231 pap_ref_data = hex_bytes('0304c023')
    232 
    233 assert(raw(pap) == pap_ref_data)
    234 
    235 pap_pkt = PPP_LCP_Option(pap_ref_data)
    236 assert isinstance(pap_pkt, PPP_LCP_Auth_Protocol_Option)
    237 assert pap_pkt.auth_protocol == 0xc023
    238 
    239 chap_sha1 = PPP_LCP_Auth_Protocol_Option(auth_protocol='Challenge-response authentication protocol', algorithm="SHA1")
    240 chap_sha1_ref_data = hex_bytes('0305c22306')
    241 
    242 assert raw(chap_sha1) == chap_sha1_ref_data
    243 
    244 chap_sha1_pkt = PPP_LCP_Option(chap_sha1_ref_data)
    245 assert isinstance(chap_sha1_pkt, PPP_LCP_Auth_Protocol_Option)
    246 assert chap_sha1_pkt.auth_protocol == 0xc223
    247 assert chap_sha1_pkt.algorithm == 6
    248 
    249 eap = PPP_LCP_Auth_Protocol_Option(auth_protocol='PPP Extensible authentication protocol', data='test')
    250 eap_ref_data = hex_bytes('0308c22774657374')
    251 
    252 assert raw(eap) == eap_ref_data
    253 
    254 eap_pkt = PPP_LCP_Option(eap_ref_data)
    255 assert isinstance(eap_pkt, PPP_LCP_Auth_Protocol_Option)
    256 assert eap_pkt.auth_protocol == 0xc227
    257 assert eap_pkt.data == b'test'
    258 
    259 = Test LCP Code-Reject
    260 ~ ppp lcp lcp_code_reject
    261 
    262 code_reject = PPP() / PPP_LCP_Code_Reject(id=42, rejected_packet=PPP_LCP(code=42, id=7, data='unknown_data'))
    263 code_reject_ref_data = hex_bytes('c021072a00142a070010756e6b6e6f776e5f64617461')
    264 
    265 assert raw(code_reject) == code_reject_ref_data
    266 
    267 code_reject_pkt = PPP(code_reject_ref_data)
    268 assert PPP_LCP_Code_Reject in code_reject_pkt
    269 assert code_reject_pkt[PPP_LCP_Code_Reject].id == 42
    270 assert isinstance(code_reject_pkt[PPP_LCP_Code_Reject].rejected_packet, PPP_LCP)
    271 assert code_reject[PPP_LCP_Code_Reject].rejected_packet.code == 42
    272 assert code_reject[PPP_LCP_Code_Reject].rejected_packet.id == 7
    273 assert code_reject[PPP_LCP_Code_Reject].rejected_packet.data == b'unknown_data'
    274 
    275 = Test LCP Protocol-Reject
    276 ~ ppp lcp lcp_protocol_reject
    277 
    278 protocol_reject = PPP() / PPP_LCP_Protocol_Reject(id=42, rejected_protocol=0x8039,
    279                                                   rejected_information=Packet(hex_bytes('0305c22306')))
    280 protocol_reject_ref_data = hex_bytes('c021082a000b80390305c22306')
    281 
    282 assert raw(protocol_reject) == protocol_reject_ref_data
    283 
    284 protocol_reject_pkt = PPP(protocol_reject_ref_data)
    285 assert PPP_LCP_Protocol_Reject in protocol_reject_pkt
    286 assert protocol_reject_pkt[PPP_LCP_Protocol_Reject].id == 42
    287 assert protocol_reject_pkt[PPP_LCP_Protocol_Reject].rejected_protocol == 0x8039
    288 assert len(protocol_reject_pkt[PPP_LCP_Protocol_Reject].rejected_information) == 5
    289 
    290 = Test LCP Discard Request
    291 ~ ppp lcp lcp_discard_request
    292 
    293 discard_request = PPP() / PPP_LCP_Discard_Request(id=7, magic_number=4242, data='test')
    294 discard_request_ref_data = hex_bytes('c0210b07000c0000109274657374')
    295 
    296 assert raw(discard_request) == discard_request_ref_data
    297 
    298 discard_request_pkt = PPP(discard_request_ref_data)
    299 assert PPP_LCP_Discard_Request in discard_request_pkt
    300 assert discard_request_pkt[PPP_LCP_Discard_Request].id == 7
    301 assert discard_request_pkt[PPP_LCP_Discard_Request].magic_number == 4242
    302 assert discard_request_pkt[PPP_LCP_Discard_Request].data == b'test'
    303 
    304 = Test LCP Terminate-Request/Terminate-Ack
    305 ~ ppp lcp lcp_terminate
    306 
    307 terminate_request = PPP() / PPP_LCP_Terminate(id=7, data='test')
    308 terminate_request_ref_data = hex_bytes('c0210507000874657374')
    309 
    310 assert raw(terminate_request) == terminate_request_ref_data
    311 
    312 terminate_request_pkt = PPP(terminate_request_ref_data)
    313 assert PPP_LCP_Terminate in terminate_request_pkt
    314 assert terminate_request_pkt[PPP_LCP_Terminate].code == 5
    315 assert terminate_request_pkt[PPP_LCP_Terminate].id == 7
    316 assert terminate_request_pkt[PPP_LCP_Terminate].data == b'test'
    317 
    318 terminate_ack = PPP() / PPP_LCP_Terminate(code='Terminate-Ack', id=7)
    319 terminate_ack_ref_data = hex_bytes('c02106070004')
    320 
    321 assert raw(terminate_ack) == terminate_ack_ref_data
    322 
    323 terminate_ack_pkt = PPP(terminate_ack_ref_data)
    324 assert PPP_LCP_Terminate in terminate_ack_pkt
    325 assert terminate_ack_pkt[PPP_LCP_Terminate].code == 6
    326 assert terminate_ack_pkt[PPP_LCP_Terminate].id == 7
    327 
    328 assert terminate_ack_pkt.answers(terminate_request_pkt)
    329 assert not terminate_request_pkt.answers(terminate_ack_pkt)
    330 
    331 + PPP PAP Tests
    332 = Test PPP PAP Request
    333 ~ ppp pap pap_request
    334 pap_request = PPP() / PPP_PAP_Request(id=42, username='administrator', password='secret_password')
    335 pap_request_ref_data = hex_bytes('c023012a00220d61646d696e6973747261746f720f7365637265745f70617373776f7264')
    336 
    337 assert raw(pap_request) == pap_request_ref_data
    338 
    339 pap_request_pkt = PPP(pap_request_ref_data)
    340 assert PPP_PAP_Request in pap_request_pkt
    341 assert pap_request_pkt[PPP_PAP_Request].code == 1
    342 assert pap_request_pkt[PPP_PAP_Request].id == 42
    343 assert pap_request_pkt[PPP_PAP_Request].username == b'administrator'
    344 assert pap_request_pkt[PPP_PAP_Request].password == b'secret_password'
    345 assert pap_request_pkt[PPP_PAP_Request].summary() in ['PAP-Request username=\'administrator\' password=\'secret_password\'',
    346                                                       'PAP-Request username=b\'administrator\' password=b\'secret_password\'']
    347 
    348 = Test PPP PAP Authenticate-Ack
    349 ~ ppp pap pap_response pap_ack
    350 pap_response = PPP() / PPP_PAP(code='Authenticate-Ack', id=42)
    351 pap_response_ref_data = hex_bytes('c023022a000500')
    352 
    353 assert raw(pap_response) == pap_response_ref_data
    354 
    355 pap_response_pkt = PPP(pap_response_ref_data)
    356 assert PPP_PAP_Response in pap_response_pkt
    357 assert pap_response_pkt[PPP_PAP_Response].code == 2
    358 assert pap_response_pkt[PPP_PAP_Response].id == 42
    359 assert pap_response_pkt[PPP_PAP_Response].msg_len == 0
    360 assert pap_response_pkt[PPP_PAP_Response].message == b''
    361 assert pap_response_pkt[PPP_PAP_Response].summary() == 'PAP-Ack'
    362 
    363 pap_request_pkt = PPP(hex_bytes('c023012a00220d61646d696e6973747261746f720f7365637265745f70617373776f7264'))
    364 assert pap_response_pkt.answers(pap_request_pkt)
    365 assert not pap_request_pkt.answers(pap_response_pkt)
    366 
    367 = Test PPP PAP Authenticate-Nak
    368 ~ ppp pap pap_response pap_nak
    369 pap_response = PPP() / PPP_PAP(code=3, id=42, message='Bad password')
    370 pap_response_ref_data = hex_bytes('c023032a00110c4261642070617373776f7264')
    371 
    372 assert raw(pap_response) == pap_response_ref_data
    373 
    374 pap_response_pkt = PPP(pap_response_ref_data)
    375 assert PPP_PAP_Response in pap_response_pkt
    376 assert pap_response_pkt[PPP_PAP_Response].code == 3
    377 assert pap_response_pkt[PPP_PAP_Response].id == 42
    378 assert pap_response_pkt[PPP_PAP_Response].msg_len == len('Bad password')
    379 assert pap_response_pkt[PPP_PAP_Response].message == b'Bad password'
    380 assert pap_response_pkt[PPP_PAP_Response].summary() in ['PAP-Nak msg=\'Bad password\'', 'PAP-Nak msg=b\'Bad password\'']
    381 
    382 pap_request_pkt = PPP(hex_bytes('c023012a00220d61646d696e6973747261746f720f7365637265745f70617373776f7264'))
    383 assert pap_response_pkt.answers(pap_request_pkt)
    384 assert not pap_request_pkt.answers(pap_response_pkt)
    385 
    386 + PPP CHAP Tests
    387 = Test PPP CHAP Challenge
    388 ~ ppp chap chap_challenge
    389 chap_challenge = PPP() / PPP_CHAP(code=1, id=47, value=b'B' * 7,
    390                                                         optional_name='server')
    391 chap_challenge_ref_data = hex_bytes('c223012f00120742424242424242736572766572')
    392 
    393 assert raw(chap_challenge) == chap_challenge_ref_data
    394 
    395 chap_challenge_pkt = PPP(chap_challenge_ref_data)
    396 assert PPP_CHAP_ChallengeResponse in chap_challenge_pkt
    397 assert chap_challenge_pkt[PPP_CHAP_ChallengeResponse].code == 1
    398 assert chap_challenge_pkt[PPP_CHAP_ChallengeResponse].id == 47
    399 assert chap_challenge_pkt[PPP_CHAP_ChallengeResponse].value_size == 7
    400 assert chap_challenge_pkt[PPP_CHAP_ChallengeResponse].value == b'B' * 7
    401 assert chap_challenge_pkt[PPP_CHAP_ChallengeResponse].optional_name == b'server'
    402 assert chap_challenge_pkt[PPP_CHAP_ChallengeResponse].summary() in ['CHAP challenge=0x42424242424242 optional_name=\'server\'',
    403                                                                     'CHAP challenge=0x42424242424242 optional_name=b\'server\'']
    404 
    405 = Test PPP CHAP Response
    406 ~ ppp chap chap_response
    407 chap_response = PPP() / PPP_CHAP(code='Response', id=47, value=b'\x00' * 16, optional_name='client')
    408 chap_response_ref_data = hex_bytes('c223022f001b1000000000000000000000000000000000636c69656e74')
    409 
    410 assert raw(chap_response) == chap_response_ref_data
    411 
    412 chap_response_pkt = PPP(chap_response_ref_data)
    413 assert PPP_CHAP_ChallengeResponse in chap_response_pkt
    414 assert chap_response_pkt[PPP_CHAP_ChallengeResponse].code == 2
    415 assert chap_response_pkt[PPP_CHAP_ChallengeResponse].id == 47
    416 assert chap_response_pkt[PPP_CHAP_ChallengeResponse].value_size == 16
    417 assert chap_response_pkt[PPP_CHAP_ChallengeResponse].value == b'\x00' * 16
    418 assert chap_response_pkt[PPP_CHAP_ChallengeResponse].optional_name == b'client'
    419 assert chap_response_pkt[PPP_CHAP_ChallengeResponse].summary() in ['CHAP response=0x00000000000000000000000000000000 optional_name=\'client\'',
    420                                                                    'CHAP response=0x00000000000000000000000000000000 optional_name=b\'client\'']
    421 
    422 chap_request = PPP(hex_bytes('c223012f00120742424242424242736572766572'))
    423 
    424 assert chap_response.answers(chap_challenge)
    425 assert not chap_challenge.answers(chap_response)
    426 
    427 = Test PPP CHAP Success
    428 ~ ppp chap chap_success
    429 
    430 chap_success = PPP() / PPP_CHAP(code='Success', id=47)
    431 chap_success_ref_data = hex_bytes('c223032f0004')
    432 
    433 assert raw(chap_success) == chap_success_ref_data
    434 
    435 chap_success_pkt = PPP(chap_success_ref_data)
    436 assert PPP_CHAP in chap_success_pkt
    437 assert chap_success_pkt[PPP_CHAP].code == 3
    438 assert chap_success_pkt[PPP_CHAP].id == 47
    439 assert chap_success_pkt[PPP_CHAP].data == b''
    440 assert chap_success_pkt[PPP_CHAP].summary() in ['CHAP Success message=\'\'', 'CHAP Success message=b\'\'']
    441 
    442 chap_response_pkt = PPP(hex_bytes('c223022f001b1000000000000000000000000000000000636c69656e74'))
    443 
    444 assert chap_success_pkt.answers(chap_response_pkt)
    445 assert not chap_response_pkt.answers(chap_success_pkt)
    446 
    447 = Test PPP CHAP Failure
    448 ~ ppp chap chap_failure
    449 chap_failure = PPP() / PPP_CHAP(code='Failure', id=47, data='Go away')
    450 chap_failure_ref_data = hex_bytes('c223042f000b476f2061776179')
    451 
    452 assert raw(chap_failure) == chap_failure_ref_data
    453 
    454 chap_failure_pkt = PPP(chap_failure_ref_data)
    455 assert PPP_CHAP in chap_failure_pkt
    456 assert chap_failure_pkt[PPP_CHAP].code == 4
    457 assert chap_failure_pkt[PPP_CHAP].id == 47
    458 assert chap_failure_pkt[PPP_CHAP].data == b'Go away'
    459 assert chap_failure_pkt[PPP_CHAP].summary() in ['CHAP Failure message=\'Go away\'', 'CHAP Failure message=b\'Go away\'']
    460 
    461 chap_response_pkt = PPP(hex_bytes('c223022f001b1000000000000000000000000000000000636c69656e74'))
    462 
    463 assert chap_failure_pkt.answers(chap_response_pkt)
    464 assert not chap_failure_pkt.answers(chap_success_pkt)
    465 
    466 + PPTP Tests
    467 = Test PPTP Start-Control-Connection-Request
    468 ~ pptp
    469 start_control_connection = PPTPStartControlConnectionRequest(framing_capabilities='Asynchronous Framing supported',
    470                                                              bearer_capabilities='Digital access supported',
    471                                                              maximum_channels=42,
    472                                                              firmware_revision=47,
    473                                                              host_name='test host name',
    474                                                              vendor_string='test vendor string')
    475 start_control_connection_ref_data = hex_bytes('009c00011a2b3c4d00010000000100000000000100000002002a00'\
    476                                     '2f7465737420686f7374206e616d65000000000000000000000000'\
    477                                     '000000000000000000000000000000000000000000000000000000'\
    478                                     '0000000000000000000000746573742076656e646f722073747269'\
    479                                     '6e6700000000000000000000000000000000000000000000000000'\
    480                                     '000000000000000000000000000000000000000000')
    481 
    482 assert raw(start_control_connection) == start_control_connection_ref_data
    483 
    484 start_control_connection_pkt = PPTP(start_control_connection_ref_data)
    485 
    486 assert isinstance(start_control_connection_pkt, PPTPStartControlConnectionRequest)
    487 assert start_control_connection_pkt.magic_cookie == 0x1a2b3c4d
    488 assert start_control_connection_pkt.protocol_version == 1
    489 assert start_control_connection_pkt.framing_capabilities == 1
    490 assert start_control_connection_pkt.bearer_capabilities == 2
    491 assert start_control_connection_pkt.maximum_channels == 42
    492 assert start_control_connection_pkt.firmware_revision == 47
    493 assert start_control_connection_pkt.host_name == b'test host name' + b'\0' * (64-len('test host name'))
    494 assert start_control_connection_pkt.vendor_string == b'test vendor string' + b'\0' * (64-len('test vendor string'))
    495 
    496 = Test PPTP Start-Control-Connection-Reply
    497 ~ pptp
    498 start_control_connection_reply = PPTPStartControlConnectionReply(result_code='General error',
    499                                                                  error_code='Not-Connected',
    500                                                                  framing_capabilities='Synchronous Framing supported',
    501                                                                  bearer_capabilities='Analog access supported',
    502                                                                  vendor_string='vendor')
    503 start_control_connection_reply_ref_data = hex_bytes('009c00011a2b3c4d00020000000102010000000200000001ffff0'\
    504                                           '1006c696e75780000000000000000000000000000000000000000'\
    505                                           '00000000000000000000000000000000000000000000000000000'\
    506                                           '000000000000000000000000076656e646f720000000000000000'\
    507                                           '00000000000000000000000000000000000000000000000000000'\
    508                                           '00000000000000000000000000000000000000000000000')
    509 
    510 assert raw(start_control_connection_reply) == start_control_connection_reply_ref_data
    511 
    512 start_control_connection_reply_pkt = PPTP(start_control_connection_reply_ref_data)
    513 
    514 assert isinstance(start_control_connection_reply_pkt, PPTPStartControlConnectionReply)
    515 assert start_control_connection_reply_pkt.magic_cookie == 0x1a2b3c4d
    516 assert start_control_connection_reply_pkt.protocol_version == 1
    517 assert start_control_connection_reply_pkt.result_code == 2
    518 assert start_control_connection_reply_pkt.error_code == 1
    519 assert start_control_connection_reply_pkt.framing_capabilities == 2
    520 assert start_control_connection_reply_pkt.bearer_capabilities == 1
    521 assert start_control_connection_reply_pkt.host_name == b'linux' + b'\0' * (64-len('linux'))
    522 assert start_control_connection_reply_pkt.vendor_string == b'vendor' + b'\0' * (64-len('vendor'))
    523 
    524 start_control_connection_request = PPTPStartControlConnectionRequest()
    525 
    526 assert start_control_connection_reply_pkt.answers(start_control_connection_request)
    527 assert not start_control_connection_request.answers(start_control_connection_reply_pkt)
    528 
    529 = Test PPTP Stop-Control-Connection-Request
    530 ~ pptp
    531 stop_control_connection = PPTPStopControlConnectionRequest(reason='Stop-Local-Shutdown')
    532 stop_control_connection_ref_data = hex_bytes('001000011a2b3c4d0003000003000000')
    533 
    534 assert raw(stop_control_connection) == stop_control_connection_ref_data
    535 
    536 stop_control_connection_pkt = PPTP(stop_control_connection_ref_data)
    537 
    538 assert isinstance(stop_control_connection_pkt, PPTPStopControlConnectionRequest)
    539 assert stop_control_connection_pkt.magic_cookie == 0x1a2b3c4d
    540 assert stop_control_connection_pkt.reason == 3
    541 
    542 = Test PPTP Stop-Control-Connection-Reply
    543 ~ pptp
    544 stop_control_connection_reply = PPTPStopControlConnectionReply(result_code='General error',error_code='PAC-Error')
    545 stop_control_connection_reply_ref_data = hex_bytes('001000011a2b3c4d0004000002060000')
    546 
    547 assert raw(stop_control_connection_reply) == stop_control_connection_reply_ref_data
    548 
    549 stop_control_connection_reply_pkt = PPTP(stop_control_connection_reply_ref_data)
    550 
    551 assert isinstance(stop_control_connection_reply_pkt, PPTPStopControlConnectionReply)
    552 assert stop_control_connection_reply_pkt.magic_cookie == 0x1a2b3c4d
    553 assert stop_control_connection_reply_pkt.result_code == 2
    554 assert stop_control_connection_reply_pkt.error_code == 6
    555 
    556 stop_control_connection_request = PPTPStopControlConnectionRequest()
    557 
    558 assert stop_control_connection_reply_pkt.answers(stop_control_connection_request)
    559 assert not stop_control_connection_request.answers(stop_control_connection_reply_pkt)
    560 
    561 = Test PPTP Echo-Request
    562 ~ pptp
    563 echo_request = PPTPEchoRequest(identifier=42)
    564 echo_request_ref_data = hex_bytes('001000011a2b3c4d000500000000002a')
    565 
    566 assert raw(echo_request) == echo_request_ref_data
    567 
    568 echo_request_pkt = PPTP(echo_request_ref_data)
    569 
    570 assert isinstance(echo_request_pkt, PPTPEchoRequest)
    571 assert echo_request_pkt.magic_cookie == 0x1a2b3c4d
    572 assert echo_request_pkt.identifier == 42
    573 
    574 = Test PPTP Echo-Reply
    575 ~ pptp
    576 echo_reply = PPTPEchoReply(identifier=42, result_code='OK')
    577 echo_reply_ref_data = hex_bytes('001400011a2b3c4d000600000000002a01000000')
    578 
    579 assert raw(echo_reply) == echo_reply_ref_data
    580 
    581 echo_reply_pkt = PPTP(echo_reply_ref_data)
    582 
    583 assert isinstance(echo_reply_pkt, PPTPEchoReply)
    584 assert echo_reply_pkt.magic_cookie == 0x1a2b3c4d
    585 assert echo_reply_pkt.identifier == 42
    586 assert echo_reply_pkt.result_code == 1
    587 assert echo_reply_pkt.error_code == 0
    588 
    589 echo_request = PPTPEchoRequest(identifier=42)
    590 
    591 assert echo_reply_pkt.answers(echo_request)
    592 assert not echo_request.answers(echo_reply)
    593 
    594 echo_request_incorrect = PPTPEchoRequest(identifier=47)
    595 
    596 assert not echo_reply_pkt.answers(echo_request_incorrect)
    597 assert not echo_request_incorrect.answers(echo_reply_pkt)
    598 
    599 = Test PPTP Outgoing-Call-Request
    600 ~ pptp
    601 outgoing_call = PPTPOutgoingCallRequest(call_id=4242, call_serial_number=47,
    602                                         minimum_bps=1000, maximum_bps=10000,
    603                                         bearer_type='Digital channel',
    604                                         pkt_window_size=16, pkt_proc_delay=1,
    605                                         phone_number_len=9, phone_number='123456789',
    606                                         subaddress='test')
    607 outgoing_call_ref_data = hex_bytes('00a800011a2b3c4d000700001092002f000003e8000027100000000200'\
    608                          '0000030010000100090000313233343536373839000000000000000000'\
    609                          '0000000000000000000000000000000000000000000000000000000000'\
    610                          '0000000000000000000000000000000000746573740000000000000000'\
    611                          '0000000000000000000000000000000000000000000000000000000000'\
    612                          '0000000000000000000000000000000000000000000000')
    613 
    614 assert raw(outgoing_call) == outgoing_call_ref_data
    615 
    616 outgoing_call_pkt = PPTP(outgoing_call_ref_data)
    617 
    618 assert isinstance(outgoing_call_pkt, PPTPOutgoingCallRequest)
    619 assert outgoing_call_pkt.magic_cookie == 0x1a2b3c4d
    620 assert outgoing_call_pkt.call_id == 4242
    621 assert outgoing_call_pkt.call_serial_number == 47
    622 assert outgoing_call_pkt.minimum_bps == 1000
    623 assert outgoing_call_pkt.maximum_bps == 10000
    624 assert outgoing_call_pkt.bearer_type == 2
    625 assert outgoing_call_pkt.framing_type == 3
    626 assert outgoing_call_pkt.pkt_window_size == 16
    627 assert outgoing_call_pkt.pkt_proc_delay == 1
    628 assert outgoing_call_pkt.phone_number_len == 9
    629 assert outgoing_call_pkt.phone_number == b'123456789' + b'\0' * (64-len('123456789'))
    630 assert outgoing_call_pkt.subaddress == b'test' + b'\0' * (64-len('test'))
    631 
    632 = Test PPTP Outgoing-Call-Reply
    633 ~ pptp
    634 outgoing_call_reply = PPTPOutgoingCallReply(call_id=4243, peer_call_id=4242,
    635                                             result_code='Busy', error_code='No-Resource',
    636                                             cause_code=42, connect_speed=5000,
    637                                             pkt_window_size=32, pkt_proc_delay=3,
    638                                             channel_id=42)
    639 outgoing_call_reply_ref_data = hex_bytes('002000011a2b3c4d00080000109310920404002a00001388002000030000002a')
    640 
    641 assert raw(outgoing_call_reply) == outgoing_call_reply_ref_data
    642 
    643 outgoing_call_reply_pkt = PPTP(outgoing_call_reply_ref_data)
    644 
    645 assert isinstance(outgoing_call_reply_pkt, PPTPOutgoingCallReply)
    646 assert outgoing_call_reply_pkt.magic_cookie == 0x1a2b3c4d
    647 assert outgoing_call_reply_pkt.call_id == 4243
    648 assert outgoing_call_reply_pkt.peer_call_id == 4242
    649 assert outgoing_call_reply_pkt.result_code == 4
    650 assert outgoing_call_reply_pkt.error_code == 4
    651 assert outgoing_call_reply_pkt.cause_code == 42
    652 assert outgoing_call_reply_pkt.connect_speed == 5000
    653 assert outgoing_call_reply_pkt.pkt_window_size == 32
    654 assert outgoing_call_reply_pkt.pkt_proc_delay == 3
    655 assert outgoing_call_reply_pkt.channel_id == 42
    656 
    657 outgoing_call_request = PPTPOutgoingCallRequest(call_id=4242)
    658 
    659 assert outgoing_call_reply_pkt.answers(outgoing_call_request)
    660 assert not outgoing_call_request.answers(outgoing_call_reply_pkt)
    661 
    662 outgoing_call_request_incorrect = PPTPOutgoingCallRequest(call_id=5656)
    663 
    664 assert not outgoing_call_reply_pkt.answers(outgoing_call_request_incorrect)
    665 assert not outgoing_call_request_incorrect.answers(outgoing_call_reply_pkt)
    666 
    667 = Test PPTP Incoming-Call-Request
    668 ~ pptp
    669 incoming_call = PPTPIncomingCallRequest(call_id=4242, call_serial_number=47, bearer_type='Digital channel',
    670                                         channel_id=12, dialed_number_len=9, dialing_number_len=10,
    671                                         dialed_number='123456789', dialing_number='0123456789',
    672                                         subaddress='test')
    673 incoming_call_ref_data = hex_bytes('00dc00011a2b3c4d000900001092002f000000020000000c0009000a313233343536373839'\
    674                          '00000000000000000000000000000000000000000000000000000000000000000000000000'\
    675                          '00000000000000000000000000000000000030313233343536373839000000000000000000'\
    676                          '00000000000000000000000000000000000000000000000000000000000000000000000000'\
    677                          '00000000000000007465737400000000000000000000000000000000000000000000000000'\
    678                          '0000000000000000000000000000000000000000000000000000000000000000000000')
    679 
    680 assert raw(incoming_call) == incoming_call_ref_data
    681 
    682 incoming_call_pkt = PPTP(incoming_call_ref_data)
    683 
    684 assert isinstance(incoming_call_pkt, PPTPIncomingCallRequest)
    685 assert incoming_call_pkt.magic_cookie == 0x1a2b3c4d
    686 assert incoming_call_pkt.call_id == 4242
    687 assert incoming_call_pkt.call_serial_number == 47
    688 assert incoming_call_pkt.bearer_type == 2
    689 assert incoming_call_pkt.channel_id == 12
    690 assert incoming_call_pkt.dialed_number_len == 9
    691 assert incoming_call_pkt.dialing_number_len == 10
    692 assert incoming_call_pkt.dialed_number == b'123456789' + b'\0' * (64-len('123456789'))
    693 assert incoming_call_pkt.dialing_number == b'0123456789' + b'\0' * (64-len('0123456879'))
    694 assert incoming_call_pkt.subaddress == b'test' + b'\0' * (64-len('test'))
    695 
    696 = Test PPTP Incoming-Call-Reply
    697 ~ pptp
    698 incoming_call_reply = PPTPIncomingCallReply(call_id=4243, peer_call_id=4242, result_code='Connected',
    699                                             error_code='None', pkt_window_size=16, pkt_transmit_delay=42)
    700 incoming_call_reply_ref_data = hex_bytes('009400011a2b3c4d000a00001093109201000010002a0000')
    701 
    702 assert raw(incoming_call_reply) == incoming_call_reply_ref_data
    703 
    704 incoming_call_reply_pkt = PPTP(incoming_call_reply_ref_data)
    705 assert isinstance(incoming_call_reply_pkt, PPTPIncomingCallReply)
    706 assert incoming_call_reply_pkt.magic_cookie == 0x1a2b3c4d
    707 assert incoming_call_reply_pkt.call_id == 4243
    708 assert incoming_call_reply_pkt.peer_call_id == 4242
    709 assert incoming_call_reply_pkt.result_code == 1
    710 assert incoming_call_reply_pkt.error_code == 0
    711 assert incoming_call_reply_pkt.pkt_window_size == 16
    712 assert incoming_call_reply_pkt.pkt_transmit_delay == 42
    713 
    714 incoming_call_req = PPTPIncomingCallRequest(call_id=4242)
    715 
    716 assert incoming_call_reply_pkt.answers(incoming_call_req)
    717 assert not incoming_call_req.answers(incoming_call_reply)
    718 
    719 incoming_call_req_incorrect = PPTPIncomingCallRequest(call_id=4343)
    720 assert not incoming_call_reply_pkt.answers(incoming_call_req_incorrect)
    721 assert not incoming_call_req_incorrect.answers(incoming_call_reply_pkt)
    722 
    723 = Test PPTP Incoming-Call-Connected
    724 ~ pptp
    725 incoming_call_connected = PPTPIncomingCallConnected(peer_call_id=4242, connect_speed=47474747,
    726                                                     pkt_window_size=16, pkt_transmit_delay=7,
    727                                                     framing_type='Any type of framing')
    728 incoming_call_connected_ref_data = hex_bytes('001c00011a2b3c4d000b00001092000002d4683b0010000700000003')
    729 
    730 assert raw(incoming_call_connected) == incoming_call_connected_ref_data
    731 
    732 incoming_call_connected_pkt = PPTP(incoming_call_connected_ref_data)
    733 assert isinstance(incoming_call_connected_pkt, PPTPIncomingCallConnected)
    734 assert incoming_call_connected_pkt.magic_cookie == 0x1a2b3c4d
    735 assert incoming_call_connected_pkt.peer_call_id == 4242
    736 assert incoming_call_connected_pkt.connect_speed == 47474747
    737 assert incoming_call_connected_pkt.pkt_window_size == 16
    738 assert incoming_call_connected_pkt.pkt_transmit_delay == 7
    739 assert incoming_call_connected_pkt.framing_type == 3
    740 
    741 incoming_call_reply = PPTPIncomingCallReply(call_id=4242)
    742 
    743 assert incoming_call_connected_pkt.answers(incoming_call_reply)
    744 assert not incoming_call_reply.answers(incoming_call_connected_pkt)
    745 
    746 incoming_call_reply_incorrect = PPTPIncomingCallReply(call_id=4243)
    747 
    748 assert not incoming_call_connected_pkt.answers(incoming_call_reply_incorrect)
    749 assert not incoming_call_reply_incorrect.answers(incoming_call_connected_pkt)
    750 
    751 = Test PPTP Call-Clear-Request
    752 ~ pptp
    753 call_clear_request = PPTPCallClearRequest(call_id=4242)
    754 call_clear_request_ref_data = hex_bytes('001000011a2b3c4d000c000010920000')
    755 
    756 assert raw(call_clear_request) == call_clear_request_ref_data
    757 
    758 call_clear_request_pkt = PPTP(call_clear_request_ref_data)
    759 
    760 assert isinstance(call_clear_request_pkt, PPTPCallClearRequest)
    761 assert call_clear_request_pkt.magic_cookie == 0x1a2b3c4d
    762 assert call_clear_request_pkt.call_id == 4242
    763 
    764 = Test PPTP Call-Disconnect-Notify
    765 ~ pptp
    766 call_disconnect_notify = PPTPCallDisconnectNotify(call_id=4242, result_code='Admin Shutdown', error_code='None',
    767                                                   cause_code=47, call_statistic='some description')
    768 call_disconnect_notify_ref_data = hex_bytes('009400011a2b3c4d000d000010920300002f0000736f6d65206465736372697074696'\
    769                                   'f6e000000000000000000000000000000000000000000000000000000000000000000'\
    770                                   '000000000000000000000000000000000000000000000000000000000000000000000'\
    771                                   '000000000000000000000000000000000000000000000000000000000000000000000'\
    772                                   '00000000000000000000')
    773 
    774 assert raw(call_disconnect_notify) == call_disconnect_notify_ref_data
    775 
    776 call_disconnect_notify_pkt = PPTP(call_disconnect_notify_ref_data)
    777 
    778 assert isinstance(call_disconnect_notify_pkt, PPTPCallDisconnectNotify)
    779 assert call_disconnect_notify_pkt.magic_cookie == 0x1a2b3c4d
    780 assert call_disconnect_notify_pkt.call_id == 4242
    781 assert call_disconnect_notify_pkt.result_code == 3
    782 assert call_disconnect_notify_pkt.error_code == 0
    783 assert call_disconnect_notify_pkt.cause_code == 47
    784 assert call_disconnect_notify_pkt.call_statistic == b'some description' + b'\0' * (128-len('some description'))
    785 
    786 = Test PPTP WAN-Error-Notify
    787 ~ pptp
    788 wan_error_notify = PPTPWANErrorNotify(peer_call_id=4242, crc_errors=1, framing_errors=2,
    789                                       hardware_overruns=3, buffer_overruns=4, time_out_errors=5,
    790                                       alignment_errors=6)
    791 wan_error_notify_ref_data = hex_bytes('002800011a2b3c4d000e000010920000000000010000000200000003000000040000000500000006')
    792 
    793 assert raw(wan_error_notify) == wan_error_notify_ref_data
    794 
    795 wan_error_notify_pkt = PPTP(wan_error_notify_ref_data)
    796 
    797 assert isinstance(wan_error_notify_pkt, PPTPWANErrorNotify)
    798 assert wan_error_notify_pkt.magic_cookie == 0x1a2b3c4d
    799 assert wan_error_notify_pkt.peer_call_id == 4242
    800 assert wan_error_notify_pkt.crc_errors == 1
    801 assert wan_error_notify_pkt.framing_errors == 2
    802 assert wan_error_notify_pkt.hardware_overruns == 3
    803 assert wan_error_notify_pkt.buffer_overruns == 4
    804 
    805 = Test PPTP Set-Link-Info
    806 ~ pptp
    807 set_link_info = PPTPSetLinkInfo(peer_call_id=4242, send_accm=0x0f0f0f0f, receive_accm=0xf0f0f0f0)
    808 set_link_info_ref_data = hex_bytes('001800011a2b3c4d000f0000109200000f0f0f0ff0f0f0f0')
    809 
    810 assert raw(set_link_info) == set_link_info_ref_data
    811 
    812 set_link_info_pkt = PPTP(set_link_info_ref_data)
    813 
    814 assert isinstance(set_link_info_pkt, PPTPSetLinkInfo)
    815 assert set_link_info_pkt.magic_cookie == 0x1a2b3c4d
    816 assert set_link_info_pkt.peer_call_id == 4242
    817 assert set_link_info_pkt.send_accm == 0x0f0f0f0f
    818 assert set_link_info_pkt.receive_accm == 0xf0f0f0f0
    819