Vadim Yanitskiy | 7d57edf | 2021-03-11 23:01:55 +0100 | [diff] [blame] | 1 | #!/usr/bin/env python3 |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 2 | |
| 3 | import unittest |
Merlin Chlosta | 05ca36b | 2021-04-01 16:15:28 +0200 | [diff] [blame] | 4 | from pySim import utils |
Harald Welte | f8d2e2b | 2023-07-09 17:58:38 +0200 | [diff] [blame] | 5 | from pySim.legacy import utils as legacy_utils |
Merlin Chlosta | 05ca36b | 2021-04-01 16:15:28 +0200 | [diff] [blame] | 6 | from pySim.ts_31_102 import EF_SUCI_Calc_Info |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 7 | |
Harald Welte | 785d484 | 2022-04-05 14:24:22 +0200 | [diff] [blame] | 8 | # we don't really want to thest TS 102 221, but the underlying DataObject codebase |
| 9 | from pySim.ts_102_221 import AM_DO_EF, AM_DO_DF, SC_DO |
| 10 | |
| 11 | class DoTestCase(unittest.TestCase): |
| 12 | |
| 13 | def testSeqOfChoices(self): |
| 14 | """A sequence of two choices with each a variety of DO/TLVs""" |
| 15 | arr_seq = utils.DataObjectSequence('arr', sequence=[AM_DO_EF, SC_DO]) |
| 16 | # input data |
| 17 | dec_in = [{'access_mode': ['update_erase', 'read_search_compare']}, {'control_reference_template':'PIN1'}] |
| 18 | # encode it once |
| 19 | encoded = arr_seq.encode(dec_in) |
| 20 | # decode again |
| 21 | re_decoded = arr_seq.decode(encoded) |
| 22 | self.assertEqual(dec_in, re_decoded[0]) |
| 23 | |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 24 | class DecTestCase(unittest.TestCase): |
Merlin Chlosta | 05ca36b | 2021-04-01 16:15:28 +0200 | [diff] [blame] | 25 | # TS33.501 Annex C.4 test keys |
| 26 | hnet_pubkey_profile_b = "0272DA71976234CE833A6907425867B82E074D44EF907DFB4B3E21C1C2256EBCD1" # ID 27 in test file |
| 27 | hnet_pubkey_profile_a = "5A8D38864820197C3394B92613B20B91633CBD897119273BF8E4A6F4EEC0A650" # ID 30 in test file |
| 28 | |
| 29 | # TS31.121 4.9.4 EF_SUCI_Calc_Info test file |
| 30 | testfile_suci_calc_info = "A006020101020000A14B80011B8121" +hnet_pubkey_profile_b +"80011E8120" +hnet_pubkey_profile_a |
| 31 | |
| 32 | decoded_testfile_suci = { |
| 33 | 'prot_scheme_id_list': [ |
| 34 | {'priority': 0, 'identifier': 2, 'key_index': 1}, |
| 35 | {'priority': 1, 'identifier': 1, 'key_index': 2}, |
| 36 | {'priority': 2, 'identifier': 0, 'key_index': 0}], |
| 37 | 'hnet_pubkey_list': [ |
| 38 | {'hnet_pubkey_identifier': 27, 'hnet_pubkey': hnet_pubkey_profile_b.lower()}, # because h2b/b2h returns all lower-case |
| 39 | {'hnet_pubkey_identifier': 30, 'hnet_pubkey': hnet_pubkey_profile_a.lower()}] |
| 40 | } |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 41 | |
| 42 | def testSplitHexStringToListOf5ByteEntries(self): |
| 43 | input_str = "ffffff0003ffffff0002ffffff0001" |
| 44 | expected = [ |
| 45 | "ffffff0003", |
| 46 | "ffffff0002", |
| 47 | "ffffff0001", |
| 48 | ] |
Harald Welte | f8d2e2b | 2023-07-09 17:58:38 +0200 | [diff] [blame] | 49 | self.assertEqual(legacy_utils.hexstr_to_Nbytearr(input_str, 5), expected) |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 50 | |
| 51 | def testDecMCCfromPLMN(self): |
| 52 | self.assertEqual(utils.dec_mcc_from_plmn("92f501"), 295) |
| 53 | |
| 54 | def testDecMCCfromPLMN_unused(self): |
| 55 | self.assertEqual(utils.dec_mcc_from_plmn("ff0f00"), 4095) |
| 56 | |
Philipp Maier | 6c5cd80 | 2021-04-23 21:19:36 +0200 | [diff] [blame] | 57 | def testDecMCCfromPLMN_str(self): |
| 58 | self.assertEqual(utils.dec_mcc_from_plmn_str("92f501"), "295") |
| 59 | |
| 60 | def testDecMCCfromPLMN_unused_str(self): |
| 61 | self.assertEqual(utils.dec_mcc_from_plmn_str("ff0f00"), "") |
| 62 | |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 63 | def testDecMNCfromPLMN_twoDigitMNC(self): |
| 64 | self.assertEqual(utils.dec_mnc_from_plmn("92f501"), 10) |
| 65 | |
| 66 | def testDecMNCfromPLMN_threeDigitMNC(self): |
| 67 | self.assertEqual(utils.dec_mnc_from_plmn("031263"), 361) |
| 68 | |
| 69 | def testDecMNCfromPLMN_unused(self): |
| 70 | self.assertEqual(utils.dec_mnc_from_plmn("00f0ff"), 4095) |
| 71 | |
Philipp Maier | 6c5cd80 | 2021-04-23 21:19:36 +0200 | [diff] [blame] | 72 | def testDecMNCfromPLMN_twoDigitMNC_str(self): |
| 73 | self.assertEqual(utils.dec_mnc_from_plmn_str("92f501"), "10") |
| 74 | |
| 75 | def testDecMNCfromPLMN_threeDigitMNC_str(self): |
| 76 | self.assertEqual(utils.dec_mnc_from_plmn_str("031263"), "361") |
| 77 | |
| 78 | def testDecMNCfromPLMN_unused_str(self): |
| 79 | self.assertEqual(utils.dec_mnc_from_plmn_str("00f0ff"), "") |
| 80 | |
Vadim Yanitskiy | c8458e2 | 2021-03-12 00:34:10 +0100 | [diff] [blame] | 81 | def test_enc_plmn(self): |
| 82 | with self.subTest("2-digit MCC"): |
| 83 | self.assertEqual(utils.enc_plmn("001", "01F"), "00F110") |
| 84 | self.assertEqual(utils.enc_plmn("001", "01"), "00F110") |
| 85 | self.assertEqual(utils.enc_plmn("295", "10"), "92F501") |
| 86 | |
| 87 | with self.subTest("3-digit MCC"): |
| 88 | self.assertEqual(utils.enc_plmn("001", "001"), "001100") |
| 89 | self.assertEqual(utils.enc_plmn("302", "361"), "031263") |
| 90 | |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 91 | def testDecAct_noneSet(self): |
| 92 | self.assertEqual(utils.dec_act("0000"), []) |
| 93 | |
| 94 | def testDecAct_onlyUtran(self): |
| 95 | self.assertEqual(utils.dec_act("8000"), ["UTRAN"]) |
| 96 | |
| 97 | def testDecAct_onlyEUtran(self): |
| 98 | self.assertEqual(utils.dec_act("4000"), ["E-UTRAN"]) |
| 99 | |
Bjoern Riemer | ffee89a | 2022-01-20 22:05:22 +0100 | [diff] [blame] | 100 | def testDecAct_onlyNgRan(self): |
| 101 | self.assertEqual(utils.dec_act("0800"), ["NG-RAN"]) |
| 102 | |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 103 | def testDecAct_onlyGsm(self): |
| 104 | self.assertEqual(utils.dec_act("0080"), ["GSM"]) |
| 105 | |
| 106 | def testDecAct_onlyGsmCompact(self): |
| 107 | self.assertEqual(utils.dec_act("0040"), ["GSM COMPACT"]) |
| 108 | |
| 109 | def testDecAct_onlyCdma2000HRPD(self): |
| 110 | self.assertEqual(utils.dec_act("0020"), ["cdma2000 HRPD"]) |
| 111 | |
| 112 | def testDecAct_onlyCdma20001xRTT(self): |
| 113 | self.assertEqual(utils.dec_act("0010"), ["cdma2000 1xRTT"]) |
| 114 | |
| 115 | def testDecAct_allSet(self): |
Bjoern Riemer | ffee89a | 2022-01-20 22:05:22 +0100 | [diff] [blame] | 116 | self.assertEqual(utils.dec_act("ffff"), ["UTRAN", "E-UTRAN WB-S1", "E-UTRAN NB-S1", "NG-RAN", "GSM", "GSM COMPACT", "cdma2000 HRPD", "cdma2000 1xRTT"]) |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 117 | |
| 118 | def testDecxPlmn_w_act(self): |
Philipp Maier | b919f8b | 2021-04-27 18:28:27 +0200 | [diff] [blame] | 119 | expected = {'mcc': '295', 'mnc': '10', 'act': ["UTRAN"]} |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 120 | self.assertEqual(utils.dec_xplmn_w_act("92f5018000"), expected) |
| 121 | |
| 122 | def testFormatxPlmn_w_act(self): |
| 123 | input_str = "92f501800092f5508000ffffff0000ffffff0000ffffff0000ffffff0000ffffff0000ffffff0000ffffff0000ffffff0000" |
Philipp Maier | b919f8b | 2021-04-27 18:28:27 +0200 | [diff] [blame] | 124 | expected = "\t92f5018000 # MCC: 295 MNC: 10 AcT: UTRAN\n" |
| 125 | expected += "\t92f5508000 # MCC: 295 MNC: 05 AcT: UTRAN\n" |
Vadim Yanitskiy | 46c49d5 | 2021-03-12 01:12:11 +0100 | [diff] [blame] | 126 | expected += "\tffffff0000 # unused\n" |
| 127 | expected += "\tffffff0000 # unused\n" |
| 128 | expected += "\tffffff0000 # unused\n" |
| 129 | expected += "\tffffff0000 # unused\n" |
| 130 | expected += "\tffffff0000 # unused\n" |
| 131 | expected += "\tffffff0000 # unused\n" |
| 132 | expected += "\tffffff0000 # unused\n" |
| 133 | expected += "\tffffff0000 # unused\n" |
Harald Welte | f8d2e2b | 2023-07-09 17:58:38 +0200 | [diff] [blame] | 134 | self.assertEqual(legacy_utils.format_xplmn_w_act(input_str), expected) |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 135 | |
Merlin Chlosta | 05ca36b | 2021-04-01 16:15:28 +0200 | [diff] [blame] | 136 | |
| 137 | def testDecodeSuciCalcInfo(self): |
| 138 | suci_calc_info = EF_SUCI_Calc_Info() |
| 139 | decoded = suci_calc_info._decode_hex(self.testfile_suci_calc_info) |
| 140 | self.assertDictEqual(self.decoded_testfile_suci, decoded) |
| 141 | |
| 142 | def testEncodeSuciCalcInfo(self): |
| 143 | suci_calc_info = EF_SUCI_Calc_Info() |
| 144 | encoded = suci_calc_info._encode_hex(self.decoded_testfile_suci) |
| 145 | self.assertEqual(encoded.lower(), self.testfile_suci_calc_info.lower()) |
| 146 | |
Philipp Maier | b46cb3f | 2021-04-20 22:38:21 +0200 | [diff] [blame] | 147 | def testEnc_msisdn(self): |
| 148 | msisdn_encoded = utils.enc_msisdn("+4916012345678", npi=0x01, ton=0x03) |
| 149 | self.assertEqual(msisdn_encoded, "0891946110325476f8ffffffffff") |
| 150 | msisdn_encoded = utils.enc_msisdn("123456", npi=0x01, ton=0x03) |
| 151 | self.assertEqual(msisdn_encoded, "04b1214365ffffffffffffffffff") |
| 152 | msisdn_encoded = utils.enc_msisdn("12345678901234567890", npi=0x01, ton=0x03) |
| 153 | self.assertEqual(msisdn_encoded, "0bb121436587092143658709ffff") |
| 154 | msisdn_encoded = utils.enc_msisdn("+12345678901234567890", npi=0x01, ton=0x03) |
| 155 | self.assertEqual(msisdn_encoded, "0b9121436587092143658709ffff") |
| 156 | msisdn_encoded = utils.enc_msisdn("", npi=0x01, ton=0x03) |
| 157 | self.assertEqual(msisdn_encoded, "ffffffffffffffffffffffffffff") |
| 158 | msisdn_encoded = utils.enc_msisdn("+", npi=0x01, ton=0x03) |
| 159 | self.assertEqual(msisdn_encoded, "ffffffffffffffffffffffffffff") |
| 160 | |
| 161 | def testDec_msisdn(self): |
| 162 | msisdn_decoded = utils.dec_msisdn("0891946110325476f8ffffffffff") |
| 163 | self.assertEqual(msisdn_decoded, (1, 1, "+4916012345678")) |
| 164 | msisdn_decoded = utils.dec_msisdn("04b1214365ffffffffffffffffff") |
| 165 | self.assertEqual(msisdn_decoded, (1, 3, "123456")) |
| 166 | msisdn_decoded = utils.dec_msisdn("0bb121436587092143658709ffff") |
| 167 | self.assertEqual(msisdn_decoded, (1, 3, "12345678901234567890")) |
| 168 | msisdn_decoded = utils.dec_msisdn("ffffffffffffffffffffffffffff") |
| 169 | self.assertEqual(msisdn_decoded, None) |
| 170 | msisdn_decoded = utils.dec_msisdn("00112233445566778899AABBCCDDEEFF001122330bb121436587092143658709ffff") |
| 171 | self.assertEqual(msisdn_decoded, (1, 3, "12345678901234567890")) |
| 172 | msisdn_decoded = utils.dec_msisdn("ffffffffffffffffffffffffffffffffffffffff0bb121436587092143658709ffff") |
| 173 | self.assertEqual(msisdn_decoded, (1, 3, "12345678901234567890")) |
| 174 | |
Harald Welte | de02718 | 2021-05-04 20:06:45 +0200 | [diff] [blame] | 175 | class TestBerTlv(unittest.TestCase): |
| 176 | def test_BerTlvTagDec(self): |
| 177 | res = utils.bertlv_parse_tag(b'\x01') |
| 178 | self.assertEqual(res, ({'tag':1, 'constructed':False, 'class': 0}, b'')) |
| 179 | res = utils.bertlv_parse_tag(b'\x21') |
| 180 | self.assertEqual(res, ({'tag':1, 'constructed':True, 'class': 0}, b'')) |
| 181 | res = utils.bertlv_parse_tag(b'\x81\x23') |
| 182 | self.assertEqual(res, ({'tag':1, 'constructed':False, 'class': 2}, b'\x23')) |
| 183 | res = utils.bertlv_parse_tag(b'\x1f\x8f\x00\x23') |
| 184 | self.assertEqual(res, ({'tag':0xf<<7, 'constructed':False, 'class': 0}, b'\x23')) |
| 185 | |
| 186 | def test_BerTlvLenDec(self): |
| 187 | self.assertEqual(utils.bertlv_encode_len(1), b'\x01') |
| 188 | self.assertEqual(utils.bertlv_encode_len(127), b'\x7f') |
| 189 | self.assertEqual(utils.bertlv_encode_len(128), b'\x81\x80') |
| 190 | self.assertEqual(utils.bertlv_encode_len(0x123456), b'\x83\x12\x34\x56') |
| 191 | |
| 192 | def test_BerTlvLenEnc(self): |
| 193 | self.assertEqual(utils.bertlv_parse_len(b'\x01\x23'), (1, b'\x23')) |
| 194 | self.assertEqual(utils.bertlv_parse_len(b'\x7f'), (127, b'')) |
| 195 | self.assertEqual(utils.bertlv_parse_len(b'\x81\x80'), (128, b'')) |
| 196 | self.assertEqual(utils.bertlv_parse_len(b'\x83\x12\x34\x56\x78'), (0x123456, b'\x78')) |
| 197 | |
Harald Welte | e750603 | 2021-05-21 21:48:11 +0200 | [diff] [blame] | 198 | def test_BerTlvParseOne(self): |
| 199 | res = utils.bertlv_parse_one(b'\x81\x01\x01'); |
| 200 | self.assertEqual(res, ({'tag':1, 'constructed':False, 'class':2}, 1, b'\x01', b'')) |
| 201 | |
Harald Welte | 9f3b44d | 2021-05-04 18:18:09 +0200 | [diff] [blame] | 202 | class TestComprTlv(unittest.TestCase): |
| 203 | def test_ComprTlvTagDec(self): |
| 204 | res = utils.comprehensiontlv_parse_tag(b'\x12\x23') |
| 205 | self.assertEqual(res, ({'tag': 0x12, 'comprehension': False}, b'\x23')) |
| 206 | res = utils.comprehensiontlv_parse_tag(b'\x92') |
| 207 | self.assertEqual(res, ({'tag': 0x12, 'comprehension': True}, b'')) |
| 208 | res = utils.comprehensiontlv_parse_tag(b'\x7f\x12\x34') |
| 209 | self.assertEqual(res, ({'tag': 0x1234, 'comprehension': False}, b'')) |
| 210 | res = utils.comprehensiontlv_parse_tag(b'\x7f\x82\x34\x56') |
| 211 | self.assertEqual(res, ({'tag': 0x234, 'comprehension': True}, b'\x56')) |
| 212 | |
| 213 | def test_ComprTlvTagEnc(self): |
| 214 | res = utils.comprehensiontlv_encode_tag(0x12) |
| 215 | self.assertEqual(res, b'\x12') |
| 216 | res = utils.comprehensiontlv_encode_tag({'tag': 0x12}) |
| 217 | self.assertEqual(res, b'\x12') |
| 218 | res = utils.comprehensiontlv_encode_tag({'tag': 0x12, 'comprehension':True}) |
| 219 | self.assertEqual(res, b'\x92') |
| 220 | res = utils.comprehensiontlv_encode_tag(0x1234) |
| 221 | self.assertEqual(res, b'\x7f\x12\x34') |
| 222 | res = utils.comprehensiontlv_encode_tag({'tag': 0x1234, 'comprehension':True}) |
| 223 | self.assertEqual(res, b'\x7f\x92\x34') |
Harald Welte | de02718 | 2021-05-04 20:06:45 +0200 | [diff] [blame] | 224 | |
Daniel Laszlo Sitzer | 851e9c0 | 2018-12-04 19:40:08 +0100 | [diff] [blame] | 225 | if __name__ == "__main__": |
| 226 | unittest.main() |