mirror of https://gerrit.osmocom.org/pysim
Initial import
Signed-off-by: Sylvain Munaut <tnt@246tNt.com>
This commit is contained in:
commit
0d1e63a978
|
@ -0,0 +1,801 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
#
|
||||
# Utility to deal with sim cards and program the 'magic' ones easily
|
||||
#
|
||||
#
|
||||
# Part of the sim link code of inspired by pySimReader-Serial-src-v2
|
||||
#
|
||||
#
|
||||
# Copyright (C) 2009 Sylvain Munaut <tnt@246tNt.com>
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 2 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
|
||||
import time
|
||||
import serial
|
||||
import sys
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------
|
||||
# Utils
|
||||
# -------------------------------------------------------------------------{{{
|
||||
|
||||
def h2b(s):
|
||||
return ''.join([chr((int(x,16)<<4)+int(y,16)) for x,y in zip(s[0::2], s[1::2])])
|
||||
|
||||
def b2h(s):
|
||||
return ''.join(['%02x'%ord(x) for x in s])
|
||||
|
||||
def swap_nibbles(s):
|
||||
return ''.join([x+y for x,y in zip(s[1::2], s[0::2])])
|
||||
|
||||
def rpad(s, l, c='f'):
|
||||
return s + c * (l - len(s))
|
||||
|
||||
def lpad(s, l, c='f'):
|
||||
return c * (l - len(s)) + s
|
||||
|
||||
def scan_all(base, start=0, end=65536):
|
||||
rv = []
|
||||
s.select_file(base)
|
||||
for v in range(start, end):
|
||||
try:
|
||||
data, sw = s.send_apdu('a0a4000002%04x' % v)
|
||||
if sw == '9000':
|
||||
rv.append( (v, data, sw) )
|
||||
s.select_file(base)
|
||||
except KeyboardInterrupt:
|
||||
return rv, v
|
||||
except:
|
||||
s.reset_card()
|
||||
return rv, end-1
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------
|
||||
# Main serial communication
|
||||
# -------------------------------------------------------------------------{{{
|
||||
|
||||
import exceptions
|
||||
|
||||
class NoCardError(exceptions.Exception):
|
||||
pass
|
||||
class ProtocolError(exceptions.Exception):
|
||||
pass
|
||||
|
||||
|
||||
class SerialSimLink(object):
|
||||
|
||||
def __init__(self, device='/dev/ttyUSB0', baudrate=9600, rst='-rts', debug=False):
|
||||
self._sl = serial.Serial(
|
||||
port = device,
|
||||
parity = serial.PARITY_EVEN,
|
||||
bytesize = serial.EIGHTBITS,
|
||||
stopbits = serial.STOPBITS_TWO,
|
||||
timeout = 1,
|
||||
xonxoff = 0,
|
||||
rtscts = 0,
|
||||
baudrate = baudrate,
|
||||
)
|
||||
self._rst_pin = rst
|
||||
self._debug = debug
|
||||
|
||||
rv = self.reset_card()
|
||||
if rv == 0:
|
||||
raise NoCardError()
|
||||
elif rv < 0:
|
||||
raise ProtocoldError()
|
||||
|
||||
def __del__(self):
|
||||
self._sl.close()
|
||||
|
||||
def reset_card(self):
|
||||
rst_meth_map = {
|
||||
'rts': self._sl.setRTS,
|
||||
'dtr': self._sl.setDTR,
|
||||
}
|
||||
rst_val_map = { '+':0, '-':1 }
|
||||
|
||||
try:
|
||||
rst_meth = rst_meth_map[self._rst_pin[1:]]
|
||||
rst_val = rst_val_map[self._rst_pin[0]]
|
||||
except:
|
||||
raise ValueError('Invalid reset pin %s' % self._rst_pin);
|
||||
|
||||
rst_meth(rst_val)
|
||||
time.sleep(0.1) # 100 ms
|
||||
self._sl.flushInput()
|
||||
rst_meth(rst_val ^ 1)
|
||||
|
||||
b = self._rx_byte()
|
||||
if not b:
|
||||
return 0
|
||||
if ord(b) != 0x3b:
|
||||
return -1;
|
||||
self._dbg_print("TS: 0x%x Direct convention" % ord(b))
|
||||
|
||||
while ord(b) == 0x3b:
|
||||
b = self._rx_byte()
|
||||
|
||||
if not b:
|
||||
return -1
|
||||
t0 = ord(b)
|
||||
self._dbg_print("T0: 0x%x" % t0)
|
||||
|
||||
for i in range(4):
|
||||
if t0 & (0x10 << i):
|
||||
self._dbg_print("T%si = %x" % (chr(ord('A')+i), ord(self._rx_byte())))
|
||||
|
||||
for i in range(0, t0 & 0xf):
|
||||
self._dbg_print("Historical = %x" % ord(self._rx_byte()))
|
||||
|
||||
while True:
|
||||
x = self._rx_byte()
|
||||
if not x:
|
||||
break
|
||||
self._dbg_print("Extra: %x" % ord(x))
|
||||
|
||||
return 1
|
||||
|
||||
def _dbg_print(self, s):
|
||||
if self._debug:
|
||||
print s
|
||||
|
||||
def _tx_byte(self, b):
|
||||
self._sl.write(b)
|
||||
r = self._sl.read()
|
||||
if r != b: # TX and RX are tied, so we must clear the echo
|
||||
raise RuntimeError("Bad echo value. Expected %02x, got %s)" % (ord(b), '%02x'%ord(r) if r else '(nil)'))
|
||||
|
||||
def _tx_string(self, s):
|
||||
"""This is only safe if it's guaranteed the card won't send any data
|
||||
during the time of tx of the string !!!"""
|
||||
self._sl.write(s)
|
||||
r = self._sl.read(len(s))
|
||||
if r != s: # TX and RX are tied, so we must clear the echo
|
||||
raise RuntimeError("Bad echo value (Expected: %s, got %s)" % (b2h(s), b2h(r)))
|
||||
|
||||
def _rx_byte(self):
|
||||
return self._sl.read()
|
||||
|
||||
def send_apdu_raw(self, pdu):
|
||||
"""send_apdu_raw(pdu): Sends an APDU with minimal processing
|
||||
|
||||
pdu : string of hexadecimal characters (ex. "A0A40000023F00")
|
||||
return : tuple(data, sw), where
|
||||
data : string (in hex) of returned data (ex. "074F4EFFFF")
|
||||
sw : string (in hex) of status word (ex. "9000")
|
||||
"""
|
||||
|
||||
pdu = h2b(pdu)
|
||||
data_len = ord(pdu[4]) # P3
|
||||
|
||||
# Send first CLASS,INS,P1,P2,P3
|
||||
self._tx_string(pdu[0:5])
|
||||
|
||||
# Wait ack which can be
|
||||
# - INS: Command acked -> go ahead
|
||||
# - 0x60: NULL, just wait some more
|
||||
# - SW1: The card can apparently proceed ...
|
||||
while True:
|
||||
b = self._rx_byte()
|
||||
if b == pdu[1]:
|
||||
break
|
||||
elif b != '\x60':
|
||||
# Ok, it 'could' be SW1
|
||||
sw1 = b
|
||||
sw2 = self._rx_byte()
|
||||
nil = self._rx_byte()
|
||||
if (sw2 and not nil):
|
||||
return '', b2h(sw1+sw2)
|
||||
|
||||
raise RuntimeError('Protocol error')
|
||||
|
||||
# Send data (if any)
|
||||
if len(pdu) > 5:
|
||||
self._tx_string(pdu[5:])
|
||||
|
||||
# Receive data (including SW !)
|
||||
# length = [P3 - tx_data (=len(pdu)-len(hdr)) + 2 (SW1/2) ]
|
||||
to_recv = data_len - len(pdu) + 5 + 2
|
||||
|
||||
data = ''
|
||||
while (len(data) < to_recv):
|
||||
b = self._rx_byte()
|
||||
if (to_recv == 2) and (b == '\x60'): # Ignore NIL if we have no RX data (hack ?)
|
||||
continue
|
||||
if not b:
|
||||
break;
|
||||
data += b
|
||||
|
||||
# Split datafield from SW
|
||||
if len(data) < 2:
|
||||
return None, None
|
||||
sw = data[-2:]
|
||||
data = data[0:-2]
|
||||
|
||||
# Return value
|
||||
return b2h(data), b2h(sw)
|
||||
|
||||
def send_apdu(self, pdu):
|
||||
"""send_apdu(pdu): Sends an APDU and auto fetch response data
|
||||
|
||||
pdu : string of hexadecimal characters (ex. "A0A40000023F00")
|
||||
return : tuple(data, sw), where
|
||||
data : string (in hex) of returned data (ex. "074F4EFFFF")
|
||||
sw : string (in hex) of status word (ex. "9000")
|
||||
"""
|
||||
data, sw = self.send_apdu_raw(pdu)
|
||||
|
||||
if (sw is not None) and (sw[0:2] == '9f'):
|
||||
pdu_gr = pdu[0:2] + 'c00000' + sw[2:4]
|
||||
data, sw = self.send_apdu_raw(pdu_gr)
|
||||
|
||||
return data, sw
|
||||
|
||||
def send_apdu_checksw(self, pdu, sw="9000"):
|
||||
"""send_apdu_checksw(pdu,sw): Sends an APDU and check returned SW
|
||||
|
||||
pdu : string of hexadecimal characters (ex. "A0A40000023F00")
|
||||
sw : string of 4 hexadecimal characters (ex. "9000")
|
||||
return : tuple(data, sw), where
|
||||
data : string (in hex) of returned data (ex. "074F4EFFFF")
|
||||
sw : string (in hex) of status word (ex. "9000")
|
||||
"""
|
||||
rv = self.send_apdu(pdu)
|
||||
if sw.lower() != rv[1]:
|
||||
raise RuntimeError("SW match failed ! Expected %s and got %s." % (sw.lower(), rv[1]))
|
||||
return rv
|
||||
|
||||
def select_file(self, dir_list):
|
||||
rv = []
|
||||
for i in dir_list:
|
||||
data, sw = self.send_apdu_checksw("a0a4000002" + i)
|
||||
rv.append(data)
|
||||
return rv
|
||||
|
||||
def read_binary(self, ef, length=None, offset=0):
|
||||
if not hasattr(type(ef), '__iter__'):
|
||||
ef = [ef]
|
||||
r = self.select_file(ef)
|
||||
if length is None:
|
||||
length = int(r[-1][4:8], 16) - offset
|
||||
pdu = 'a0b0%04x%02x' % (offset, (min(256, length) & 0xff))
|
||||
return self.send_apdu(pdu)
|
||||
|
||||
def update_binary(self, ef, data, offset=0):
|
||||
if not hasattr(type(ef), '__iter__'):
|
||||
ef = [ef]
|
||||
self.select_file(ef)
|
||||
pdu = 'a0d6%04x%02x' % (offset, len(data)/2) + data
|
||||
return self.send_apdu(pdu)
|
||||
|
||||
def read_record(self, ef, rec_no):
|
||||
if not hasattr(type(ef), '__iter__'):
|
||||
ef = [ef]
|
||||
r = self.select_file(ef)
|
||||
rec_length = int(r[-1][28:30], 16)
|
||||
pdu = 'a0b2%02x04%02x' % (rec_no, rec_length)
|
||||
return self.send_apdu(pdu)
|
||||
|
||||
def update_record(self, ef, rec_no, data, force_len=False):
|
||||
if not hasattr(type(ef), '__iter__'):
|
||||
ef = [ef]
|
||||
r = self.select_file(ef)
|
||||
if not force_len:
|
||||
rec_length = int(r[-1][28:30], 16)
|
||||
if (len(data)/2 != rec_length):
|
||||
raise ValueError('Invalid data length (expected %d, got %d)' % (rec_length, len(data)/2))
|
||||
else:
|
||||
rec_length = len(data)/2
|
||||
pdu = ('a0dc%02x04%02x' % (rec_no, rec_length)) + data
|
||||
return self.send_apdu(pdu)
|
||||
|
||||
def record_size(self, ef):
|
||||
r = self.select_file(ef)
|
||||
return int(r[-1][28:30], 16)
|
||||
|
||||
def record_count(self, ef):
|
||||
r = self.select_file(ef)
|
||||
return int(r[-1][4:8], 16) // int(r[-1][28:30], 16)
|
||||
|
||||
def run_gsm(self, rand):
|
||||
if len(rand) != 32:
|
||||
raise ValueError('Invalid rand')
|
||||
self.select_file(['3f00', '7f20'])
|
||||
return self.send_apdu('a088000010' + rand)
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------
|
||||
# Cards model
|
||||
# -------------------------------------------------------------------------{{{
|
||||
|
||||
class Card(object):
|
||||
|
||||
def __init__(self, sl):
|
||||
self._sl = sl
|
||||
|
||||
def _e_iccid(self, iccid):
|
||||
return swap_nibbles(iccid)
|
||||
|
||||
def _e_imsi(self, imsi):
|
||||
"""Converts a string imsi into the value of the EF"""
|
||||
l = (len(imsi) + 1) // 2 # Required bytes
|
||||
oe = len(imsi) & 1 # Odd (1) / Even (0)
|
||||
ei = '%02x' % l + swap_nibbles(lpad('%01x%s' % ((oe<<3)|1, imsi), 16))
|
||||
return ei
|
||||
|
||||
def _e_plmn(self, mcc, mnc):
|
||||
"""Converts integer MCC/MNC into 6 bytes for EF"""
|
||||
return swap_nibbles(lpad('%d' % mcc, 3) + lpad('%d' % mnc, 3))
|
||||
|
||||
|
||||
class _MagicSimBase(Card):
|
||||
"""
|
||||
Theses cards uses several record based EFs to store the provider infos,
|
||||
each possible provider uses a specific record number in each EF. The
|
||||
indexes used are ( where N is the number of providers supported ) :
|
||||
- [2 .. N+1] for the operator name
|
||||
- [1 .. N] for the programable EFs
|
||||
|
||||
* 3f00/7f4d/8f0c : Operator Name
|
||||
|
||||
bytes 0-15 : provider name, padded with 0xff
|
||||
byte 16 : length of the provider name
|
||||
byte 17 : 01 for valid records, 00 otherwise
|
||||
|
||||
* 3f00/7f4d/8f0d : Programmable Binary EFs
|
||||
|
||||
* 3f00/7f4d/8f0e : Programmable Record EFs
|
||||
|
||||
"""
|
||||
|
||||
@classmethod
|
||||
def autodetect(kls, sl):
|
||||
try:
|
||||
for p, l, t in kls._files.values():
|
||||
if not t:
|
||||
continue
|
||||
if sl.record_size(['3f00', '7f4d', p]) != l:
|
||||
return None
|
||||
except:
|
||||
return None
|
||||
|
||||
return kls(sl)
|
||||
|
||||
def _get_count(self):
|
||||
"""
|
||||
Selects the file and returns the total number of entries
|
||||
and entry size
|
||||
"""
|
||||
f = self._files['name']
|
||||
|
||||
r = self._sl.select_file(['3f00', '7f4d', f[0]])
|
||||
rec_len = int(r[-1][28:30], 16)
|
||||
tlen = int(r[-1][4:8],16)
|
||||
rec_cnt = (tlen / rec_len) - 1;
|
||||
|
||||
if (rec_cnt < 1) or (rec_len != f[1]):
|
||||
raise RuntimeError('Bad card type')
|
||||
|
||||
return rec_cnt
|
||||
|
||||
def program(self, p):
|
||||
# Go to dir
|
||||
self._sl.select_file(['3f00', '7f4d'])
|
||||
|
||||
# Home PLMN in PLMN_Sel format
|
||||
hplmn = self._e_plmn(p['mcc'], p['mnc'])
|
||||
|
||||
# Operator name ( 3f00/7f4d/8f0c )
|
||||
self._sl.update_record('8f0c', 2,
|
||||
rpad(b2h(p['name']), 32) + ('%02x' % len(p['name'])) + '01'
|
||||
)
|
||||
|
||||
# ICCID/IMSI/Ki/HPLMN ( 3f00/7f4d/8f0d )
|
||||
self._sl.update_record('8f0d', 1,
|
||||
rpad(
|
||||
# ICCID
|
||||
'3f00' + '2fe2' + '0a' + self._e_iccid(p['iccid']) +
|
||||
|
||||
# IMSI
|
||||
'7f20' + '6f07' + '09' + self._e_imsi(p['imsi']) +
|
||||
|
||||
# Ki
|
||||
'6f1b' + '10' + p['ki'] +
|
||||
|
||||
# PLMN_Sel
|
||||
'6f30' + '18' + rpad(hplmn, 36)
|
||||
|
||||
, self._files['b_ef'][1]*2)
|
||||
)
|
||||
|
||||
# SMSP ( 3f00/7f4d/8f0e )
|
||||
# FIXME
|
||||
|
||||
# Write PLMN_Sel forcefully as well
|
||||
r = self._sl.select_file(['3f00', '7f20', '6f30'])
|
||||
tl = int(r[-1][4:8], 16)
|
||||
|
||||
hplmn = self._e_plmn(p['mcc'], p['mnc'])
|
||||
self._sl.update_binary('6f30', hplmn + 'ff' * (tl-3))
|
||||
|
||||
def erase(self):
|
||||
# Dummy
|
||||
df = {}
|
||||
for k, v in self._files.iteritems():
|
||||
ofs = 1
|
||||
fv = v[1] * 'ff'
|
||||
if k == 'name':
|
||||
ofs = 2
|
||||
fv = fv[0:-4] + '0000'
|
||||
df[v[0]] = (fv, ofs)
|
||||
|
||||
# Write
|
||||
for n in range(0,self._get_count()):
|
||||
for k, (msg, ofs) in df.iteritems():
|
||||
self._sl.update_record(['3f00', '7f4d', k], n + ofs, msg)
|
||||
|
||||
|
||||
class SuperSim(_MagicSimBase):
|
||||
|
||||
name = 'supersim'
|
||||
|
||||
_files = {
|
||||
'name' : ('8f0c', 18, True),
|
||||
'b_ef' : ('8f0d', 74, True),
|
||||
'r_ef' : ('8f0e', 50, True),
|
||||
}
|
||||
|
||||
|
||||
class MagicSim(_MagicSimBase):
|
||||
|
||||
name = 'magicsim'
|
||||
|
||||
_files = {
|
||||
'name' : ('8f0c', 18, True),
|
||||
'b_ef' : ('8f0d', 130, True),
|
||||
'r_ef' : ('8f0e', 102, False),
|
||||
}
|
||||
|
||||
|
||||
class FakeMagicSim(Card):
|
||||
"""
|
||||
Theses cards have a record based EF 3f00/000c that contains the provider
|
||||
informations. See the program method for its format. The records go from
|
||||
1 to N.
|
||||
"""
|
||||
|
||||
name = 'fakemagicsim'
|
||||
|
||||
@classmethod
|
||||
def autodetect(kls, sl):
|
||||
try:
|
||||
if sl.record_size(['3f00', '000c']) != 0x5a:
|
||||
return None
|
||||
except:
|
||||
return None
|
||||
|
||||
return kls(sl)
|
||||
|
||||
def _get_infos(self):
|
||||
"""
|
||||
Selects the file and returns the total number of entries
|
||||
and entry size
|
||||
"""
|
||||
|
||||
r = self._sl.select_file(['3f00', '000c'])
|
||||
rec_len = int(r[-1][28:30], 16)
|
||||
tlen = int(r[-1][4:8],16)
|
||||
rec_cnt = (tlen / rec_len) - 1;
|
||||
|
||||
if (rec_cnt < 1) or (rec_len != 0x5a):
|
||||
raise RuntimeError('Bad card type')
|
||||
|
||||
return rec_cnt, rec_len
|
||||
|
||||
def program(self, p):
|
||||
# Home PLMN
|
||||
r = self._sl.select_file(['3f00', '7f20', '6f30'])
|
||||
tl = int(r[-1][4:8], 16)
|
||||
|
||||
hplmn = self._e_plmn(p['mcc'], p['mnc'])
|
||||
self._sl.update_binary('6f30', hplmn + 'ff' * (tl-3))
|
||||
|
||||
# Get total number of entries and entry size
|
||||
rec_cnt, rec_len = self._get_infos()
|
||||
|
||||
# Set first entry
|
||||
entry = (
|
||||
'81' + # 1b Status: Valid & Active
|
||||
rpad(b2h(p['name'][0:14]), 28) + # 14b Entry Name
|
||||
self._e_iccid(p['iccid']) + # 10b ICCID
|
||||
self._e_imsi(p['imsi']) + # 9b IMSI_len + id_type(9) + IMSI
|
||||
p['ki'] + # 16b Ki
|
||||
24*'f' + 'fd' + 24*'f' + # 25b (unknown ...)
|
||||
rpad(p['smsp'], 20) + # 10b SMSP (padded with ff if needed)
|
||||
10*'f' # 5b (unknown ...)
|
||||
)
|
||||
self._sl.update_record('000c', 1, entry)
|
||||
|
||||
def erase(self):
|
||||
# Get total number of entries and entry size
|
||||
rec_cnt, rec_len = self._get_infos()
|
||||
|
||||
# Erase all entries
|
||||
entry = 'ff' * rec_len
|
||||
for i in range(0, rec_cnt):
|
||||
self._sl.update_record('000c', 1+i, entry)
|
||||
|
||||
|
||||
# In order for autodetection ...
|
||||
_cards_classes = [ FakeMagicSim, SuperSim, MagicSim ]
|
||||
|
||||
# }}}
|
||||
|
||||
|
||||
# ----------------------------------------------------------------------------
|
||||
# Main
|
||||
# -------------------------------------------------------------------------{{{
|
||||
|
||||
import hashlib
|
||||
from optparse import OptionParser
|
||||
import random
|
||||
import re
|
||||
|
||||
|
||||
def parse_options():
|
||||
|
||||
parser = OptionParser(usage="usage: %prog [options]")
|
||||
|
||||
parser.add_option("-d", "--device", dest="device", metavar="DEV",
|
||||
help="Serial Device for SIM access [default: %default]",
|
||||
default="/dev/ttyUSB0",
|
||||
)
|
||||
parser.add_option("-b", "--baud", dest="baudrate", type="int", metavar="BAUD",
|
||||
help="Baudrate used for SIM access [default: %default]",
|
||||
default=9600,
|
||||
)
|
||||
parser.add_option("-t", "--type", dest="type",
|
||||
help="Card type (user -t list to view) [default: %default]",
|
||||
default="auto",
|
||||
)
|
||||
parser.add_option("-e", "--erase", dest="erase", action='store_true',
|
||||
help="Erase beforehand [default: %default]",
|
||||
default=False,
|
||||
)
|
||||
|
||||
parser.add_option("-n", "--name", dest="name",
|
||||
help="Operator name [default: %default]",
|
||||
default="Magic",
|
||||
)
|
||||
parser.add_option("-c", "--country", dest="country", type="int", metavar="CC",
|
||||
help="Country code [default: %default]",
|
||||
default=1,
|
||||
)
|
||||
parser.add_option("-x", "--mcc", dest="mcc", type="int",
|
||||
help="Mobile Country Code [default: %default]",
|
||||
default=901,
|
||||
)
|
||||
parser.add_option("-y", "--mnc", dest="mnc", type="int",
|
||||
help="Mobile Network Code",
|
||||
default=55,
|
||||
)
|
||||
parser.add_option("-m", "--smsp", dest="smsp",
|
||||
help="SMSP [default: '00 + country code + 5555']",
|
||||
)
|
||||
|
||||
parser.add_option("-s", "--iccid", dest="iccid", metavar="ID",
|
||||
help="Integrated Circuit Card ID",
|
||||
)
|
||||
parser.add_option("-i", "--imsi", dest="imsi",
|
||||
help="International Mobile Subscriber Identity",
|
||||
)
|
||||
parser.add_option("-k", "--ki", dest="ki",
|
||||
help="Ki (default is to randomize)",
|
||||
)
|
||||
|
||||
parser.add_option("-z", "--secret", dest="secret", metavar="STR",
|
||||
help="Secret used for ICCID/IMSI autogen",
|
||||
)
|
||||
parser.add_option("-j", "--num", dest="num", type=int,
|
||||
help="Card # used for ICCID/IMSI autogen",
|
||||
)
|
||||
|
||||
(options, args) = parser.parse_args()
|
||||
|
||||
if options.type == 'list':
|
||||
for kls in _cards_classes:
|
||||
print kls.name
|
||||
sys.exit(0)
|
||||
|
||||
if ((options.imsi is None) or (options.iccid is None)) and (options.num is None):
|
||||
parser.error("If either IMSI or ICCID isn't specified, num is required")
|
||||
|
||||
if args:
|
||||
parser.error("Extraneous arguments")
|
||||
|
||||
return options
|
||||
|
||||
|
||||
def _digits(secret, usage, len, num):
|
||||
s = hashlib.sha1(secret + usage + '%d' % num)
|
||||
d = ''.join(['%02d'%ord(x) for x in s.digest()])
|
||||
return d[0:len]
|
||||
|
||||
def _mcc_mnc_digits(mcc, mnc):
|
||||
return ('%03d%03d' if mnc > 100 else '%03d%02d') % (mcc, mnc)
|
||||
|
||||
def _cc_digits(cc):
|
||||
return ('%03d' if cc > 100 else '%02d') % cc
|
||||
|
||||
def _isnum(s, l=-1):
|
||||
return s.isdigit() and ((l== -1) or (len(s) == l))
|
||||
|
||||
|
||||
def gen_parameters(opts):
|
||||
"""Generates Name, ICCID, MCC, MNC, IMSI, SMSP, Ki from the
|
||||
options given by the user"""
|
||||
|
||||
# MCC/MNC
|
||||
mcc = opts.mcc
|
||||
mnc = opts.mnc
|
||||
|
||||
if not ((0 < mcc < 999) and (0 < mnc < 999)):
|
||||
raise ValueError('mcc & mnc must be between 0 and 999')
|
||||
|
||||
# Digitize country code (2 or 3 digits)
|
||||
cc_digits = _cc_digits(opts.country)
|
||||
|
||||
# Digitize MCC/MNC (5 or 6 digits)
|
||||
plmn_digits = _mcc_mnc_digits(mcc, mnc)
|
||||
|
||||
# ICCID (20 digits)
|
||||
if opts.iccid is not None:
|
||||
iccid = opts.iccid
|
||||
if not _isnum(iccid, 20):
|
||||
raise ValueError('ICCID must be 20 digits !');
|
||||
|
||||
else:
|
||||
if opts.num is None:
|
||||
raise ValueError('Neither ICCID nor card number specified !')
|
||||
|
||||
iccid = (
|
||||
'89' + # Common prefix (telecom)
|
||||
cc_digits + # Country Code on 2/3 digits
|
||||
plmn_digits # MCC/MNC on 5/6 digits
|
||||
)
|
||||
|
||||
ml = 20 - len(iccid)
|
||||
|
||||
if opts.secret is None:
|
||||
# The raw number
|
||||
iccid += ('%%0%dd' % ml) % opts.num
|
||||
else:
|
||||
# Randomized digits
|
||||
iccid += _digits(opts.secret, 'ccid', ml, opts.num)
|
||||
|
||||
# IMSI (15 digits usually)
|
||||
if opts.imsi is not None:
|
||||
imsi = opts.imsi
|
||||
if not _isnum(imsi):
|
||||
raise ValueError('IMSI must be digits only !')
|
||||
|
||||
else:
|
||||
if opts.num is None:
|
||||
raise ValueError('Neither IMSI nor card number specified !')
|
||||
|
||||
ml = 15 - len(plmn_digits)
|
||||
|
||||
if opts.secret is None:
|
||||
# The raw number
|
||||
msin = ('%%0%dd' % ml) % opts.num
|
||||
else:
|
||||
# Randomized digits
|
||||
msin = _digits(opts.secret, 'imsi', ml, opts.num)
|
||||
|
||||
imsi = (
|
||||
plmn_digits + # MCC/MNC on 5/6 digits
|
||||
msin # MSIN
|
||||
)
|
||||
|
||||
# SMSP
|
||||
if opts.smsp is not None:
|
||||
smsp = opts.smsp
|
||||
if not _isnum(smsp):
|
||||
raise ValueError('SMSP must be digits only !')
|
||||
|
||||
else:
|
||||
smsp = '00%d' % opts.country + '5555' # Hack ...
|
||||
|
||||
# Ki (random)
|
||||
if opts.ki is not None:
|
||||
ki = opts.ki
|
||||
if not re.match('^[0-9a-fA-F]{32}$', ki):
|
||||
raise ValueError('Ki needs to be 128 bits, in hex format')
|
||||
|
||||
else:
|
||||
ki = ''.join(['%02x' % random.randrange(0,256) for i in range(16)])
|
||||
|
||||
# Return that
|
||||
return {
|
||||
'name' : opts.name,
|
||||
'iccid' : iccid,
|
||||
'mcc' : mcc,
|
||||
'mnc' : mnc,
|
||||
'imsi' : imsi,
|
||||
'smsp' : smsp,
|
||||
'ki' : ki,
|
||||
}
|
||||
|
||||
|
||||
def print_parameters(params):
|
||||
|
||||
print """Generated card parameters :
|
||||
> Name : %(name)s
|
||||
> SMSP : %(smsp)s
|
||||
> ICCID : %(iccid)s
|
||||
> MCC/MNC : %(mcc)d/%(mnc)d
|
||||
> IMSI : %(imsi)s
|
||||
> Ki : %(ki)s
|
||||
""" % params
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
# Get/Gen the parameters
|
||||
opts = parse_options()
|
||||
cp = gen_parameters(opts)
|
||||
print_parameters(cp)
|
||||
|
||||
# Connect to the card
|
||||
sl = SerialSimLink(device=opts.device, baudrate=opts.baudrate)
|
||||
|
||||
# Detect type if needed
|
||||
card = None
|
||||
ctypes = dict([(kls.name, kls) for kls in _cards_classes])
|
||||
|
||||
if opts.type == "auto":
|
||||
for kls in _cards_classes:
|
||||
card = kls.autodetect(sl)
|
||||
if card:
|
||||
print "Autodetected card type %s" % card.name
|
||||
break
|
||||
|
||||
if card is None:
|
||||
print "Autodetection failed"
|
||||
sys.exit(-1)
|
||||
|
||||
elif opts.type in ctypes:
|
||||
card = ctypes[opts.type](sl)
|
||||
|
||||
else:
|
||||
print "Unknown card type %s" % opts.type
|
||||
sys.exit(-1)
|
||||
|
||||
# Erase it if asked
|
||||
if opts.erase:
|
||||
print "Formatting ..."
|
||||
card.erase()
|
||||
|
||||
# Program it
|
||||
print "Programming ..."
|
||||
card.program(cp)
|
||||
|
||||
print "Done !"
|
||||
|
Loading…
Reference in New Issue