cvs.zerfleddert.de Git - proxmark3-svn/blame_incremental

... / ...

Commit	Line	Data
	1	--[[
	2	if it don't works with you tag-layout - be so kind and let me know ;-)
	3
	4	Tested on Tags with those Layouts:
	5
	6	(example) Legic-Prime Layout with 'Kaba Group Header'
	7	+----+----+----+----+----+----+----+----+
	8	0x00\|MCD \|MSN0\|MSN1\|MSN2\|MCC \| 60 \| ea \| 9f \|
	9	+----+----+----+----+----+----+----+----+
	10	0x08\| ff \| 00 \| 00 \| 00 \| 11 \|Bck0\|Bck1\|Bck2\|
	11	+----+----+----+----+----+----+----+----+
	12	0x10\|Bck3\|Bck4\|Bck5\|BCC \| 00 \| 00 \|Seg0\|Seg1\|
	13	+----+----+----+----+----+----+----+----+
	14	0x18\|Seg2\|Seg3\|SegC\|Stp0\|Stp1\|Stp2\|Stp3\|UID0\|
	15	+----+----+----+----+----+----+----+----+
	16	0x20\|UID1\|UID2\|kghC\|
	17	+----+----+----+
	18	MCD = Manufacturer ID
	19	MSN = Manufacturer SerialNumber
	20	60 ea = DCF Low + DCF high
	21	9f = raw byte which holds the bits for OLE,WRP,WRC,RD
	22	ff = unknown but important
	23	00 = unimportant
	24	11 = unknown but important
	25	Bck = header-backup-area
	26	00 00 = Year (00 = 2000) & Week (not important)
	27	Seg = Segment Header
	28	SegC = Crc8 over the Segment Header
	29	Stp = Stamp (could be more as 4 - up to 7)
	30	UID = dec User-ID for online-Mapping
	31	kghC = crc8 over MCD + MSN0..MSN2 + UID
	32
	33
	34	(example) Legic-Cash on MIM256/1024 tag' (37 bytes)
	35	+----+----+----+----+----+----+----+----+
	36	0x00\|Seg0\|Seg1\|Seg2\|Seg3\|SegC\|STP0\|STP1\|STP2\|
	37	+----+----+----+----+----+----+----+----+
	38	0x08\|STP3\|STP4\|STP5\|STP6\| 01 \|CURh\|CURl\|LIMh\|
	39	+----+----+----+----+----+----+----+----+
	40	0x10\|LIMm\|LIMl\|CHKh\|CHKl\|BALh\|BALm\|BALl\|LRBh\|
	41	+----+----+----+----+----+----+----+----+
	42	0x18\|LRBm\|LRBl\|CHKh\|CHKl\|SHDh\|SHDm\|SHDl\|LRSh\|
	43	+----+----+----+----+----+----+----+----+
	44	0x20\|LRSm\|LRSl\| CV \|CHKh\|CHKl\|
	45	+----+----+----+----+----+
	46	STP = Stamp (seems to be always 7 bytes)
	47	01 = unknown but important
	48	CUR = currency in HEX (ISO 4217)
	49	LIM = Cash-Limit
	50	CHK = crc16 over byte-addr 0x05..0x12
	51	BAL = Balance
	52	LRB = ID of the reader that changed the balance
	53	CHK = crc16 over BAL + LRB
	54	SHD = shadow Balance
	55	LRS = ID of the reader that changed the shadow balance (?? should be always the same as LRB)
	56	CV = Counter value for transactions
	57	CHK = crc16 over SHD + LRS + CV
	58
	59	(example) Legic-Prime Layout 'gantner unsegmented user-credential'
	60	+----+----+----+----+----+----+----+----+
	61	0x00\|MCD \|MSN0\|MSN1\|MSN2\|MCC \| 60 \| ea \| 08 \|
	62	+----+----+----+----+----+----+----+----+
	63	0x08\|Stp0\|Stp1\|Stp2\|Stp3\|Stp4\|Dat0\|Dat1\|uCRC\| <- addr 0x08..0x0f is WRP
	64	+----+----+----+----+----+----+----+----+
	65	0x10\|emb0\| <- this is only within wrp if addr 0x07==09
	66	+----+
	67	MCD = Manufacturer ID
	68	MSN = Manufacturer SerialNumber
	69	60 ea = DCF Low + DCF high
	70	08 = raw byte which holds the bits for OLE,WRP,WRC,RD
	71	Stp = Stamp (could be more as 4 - up to 7)
	72	Dat = Online-Mapping Data
	73	uCRC = crc8 over addr 0x00..0x03+0x07..0x0E
	74
	75
	76	(example) Legic-Prime Layout 'gantner unsegmented Master-Token (IAM) with a stamp_len of 4'
	77	+----+----+----+----+----+----+----+----+
	78	0x00\|MCD \|MSN0\|MSN1\|MSN2\|MCC \| 20 \| f8 \| 08 \|
	79	+----+----+----+----+----+----+----+----+
	80	0x08\|Stp0\|Stp1\|Stp2\|Stp3\| 00 \| 00 \| 00 \|CRC1\|
	81	+----+----+----+----+----+----+----+----+
	82	0x10\| 00 \| 00 \| 00 \| 00 \| 00 \|CRC2\|
	83	+----+----+----+----+----+----+
	84	MCD = Manufacturer ID
	85	MSN = Manufacturer SerialNumber
	86	60 ea = DCF Low + DCF high
	87	08 = raw byte which holds the bits for OLE,WRP,WRC,RD
	88	Stp = Stamp (could be more as 4 - up to 7)
	89	Dat = Online-Mapping Data
	90	CRC1 = crc8 over addr 0x00..0x03+0x07..0x0E (special 'gantner crc8')
	91	CRC2 = MCD + MSB0..2+ addr 0x06 + addr 0x05 + addr 0x07 + Stamp (regular Master-Token-CRC)
	92	--]]
	93
	94	example = "script run legic"
	95	author = "Mosci"
	96	version = "1.0.3"
	97
	98	desc =
	99	[[
	100
	101	This script helps you to read, create and modify Legic Prime Tags (MIM22, MIM256, MIM1024)
	102	it's kinda interactive with following commands in three categories:
	103
	104	Data I/O Segment Manipulation Token-Data
	105	----------------- -------------------- -----------------
	106	rt => read Tag as => add Segment mt => make Token
	107	wt => write Tag es => edit Segment Header et => edit Token data
	108	ed => edit Segment Data tk => toggle KGH-Flag
	109	File I/O rs => remove Segment
	110	----------------- cc => check Segment-CRC
	111	lf => load File ck => check KGH
	112	sf => save File ds => dump Segments
	113	xf => xor to File
	114
	115
	116	(partially) known Segments Virtual Tags Script Output
	117	--------------------------- ------------------------------- ------------------------
	118	dlc => dump Legic-Cash ct => copy mainTag to backupTag tac => toggle ansicolors
	119	elc => edit Legic-Cash tc => copy backupTag to mainTag
	120	d3p => dump 3rd-Party-Cash tt => switch mainTag & backupTag
	121	e3p => edit 3rd-Party-Cash di => dump mainTag
	122	do => dump backupTag
	123
	124
	125
	126	rt: 'read tag' - reads a tag placed near to the PM3
	127	wt: 'write tag' - writes the content of the 'virtual inTag' to a tag placed near to th PM3
	128	without the need of changing anything - MCD,MSN,MCC will be read from the tag
	129	before and applied to the output.
	130
	131	lf: 'load file' - load a (xored) file from the local Filesystem into the 'virtual inTag'
	132	sf: 'save file' - saves the 'virtual inTag' to the local Filesystem (xored with Tag-MCC)
	133	xf: 'xor file' - saves the 'virtual inTag' to the local Filesystem (xored with choosen MCC - use '00' for plain values)
	134
	135	ct: 'copy tag' - copy the 'virtual Tag' to a second 'virtual TAG' - not usefull yet, but inernally needed
	136	tc: 'copy tag' - copy the 'second virtual Tag' to 'virtual TAG' - not usefull yet, but inernally needed
	137	tt: 'toggle tag' - copy mainTag to BackupTag and backupTag to mainTag
	138
	139	di: 'dump mainTag' - shows the current content of the 'virtual Tag'
	140	do: 'dump backupTag' - shows the current content of the 'virtual outTag'
	141	ds: 'dump Segments' - will show the content of a selected Segment
	142	as: 'add Segment' - will add a 'empty' Segment to the inTag
	143	es: 'edit Segment' - edit the Segment-Header of a selected Segment (len, WRP, WRC, RD, valid)
	144	all other Segment-Header-Values are either calculated or not needed to edit (yet)
	145	ed: 'edit data' - edit the Data of a Segment (ADF-Aera / Stamp & Payload specific Data)
	146	et: 'edit Token' - edit Data of a Token (CDF-Area / SAM, SAM64, SAM63, IAM, GAM specific Data)
	147	mt: 'make Token' - create a Token 'from scratch' (guided)
	148	rs: 'remove segment' - removes a Segment (except Segment 00, but this can be set to valid=0 for Master-Token)
	149	cc: 'check Segment-CRC'- checks & calculates (if check failed) the Segment-CRC of all Segments
	150	ck: 'check KGH-CRC' - checks the and calculates a 'Kaba Group Header' if one was detected
	151	'Kaba Group Header CRC calculation'
	152	tk: 'toggle KGH' - toglle the (script-internal) flag for kgh-calculation for a segment
	153	xc: 'etra c' - show string that was used to calculate the kgh-crc of a segment
	154
	155	dlc: 'dump Legic-Cash' - show balance and checksums of a Legic-Cash Segment
	156	elc: 'edit Legic-Cash' - edit values of a Legic-Cash Segment
	157
	158	d3p: 'dump 3rd Party' - show balance, history and checksums of a (yet) unknown 3rd-Party Cash Segment
	159	e3p: 'edit 3rd Party' - edit Data in 3rd-Party Cash Segment
	160
	161	tac: 'toggle ansicolors'- switch on and off the colored text-output of this script
	162	default can be changed by setting the variable 'colored_output' to false
	163	]]
	164	currentTag="inTAG"
	165
	166	---
	167	-- requirements
	168	local utils = require('utils')
	169	local getopt = require('getopt')
	170	local ansicolors = require('ansicolors')
	171
	172	---
	173	-- global variables / defines
	174	local bxor = bit32.bxor
	175	local bbit = bit32.extract
	176	local input = utils.input
	177	local confirm = utils.confirm
	178
	179	---
	180	-- init ansicolor-values & ansicolors switch
	181	local colored_output = true
	182	local acoff = ""
	183	local acgreen= ""
	184	local accyan = ""
	185	local acred = ""
	186	local acyellow = ""
	187	local acblue = ""
	188	local acmagenta = ""
	189
	190	--- Helper ---
	191	---
	192	-- default colors (change to whatever you want)
	193	function load_colors(onoff)
	194	if (onoff) then
	195	-- colors
	196	acgreen = ansicolors.green
	197	accyan = ansicolors.cyan
	198	acred = ansicolors.red
	199	acyellow= ansicolors.yellow
	200	acblue = ansicolors.blue
	201	acmagenta= ansicolors.magenta
	202	acoff = ansicolors.reset
	203	else
	204	-- 'no color'
	205	acgreen = ""
	206	accyan = ""
	207	acred = ""
	208	acyellow= ""
	209	acblue = ""
	210	acmagenta= ""
	211	acoff = ""
	212	end
	213	end
	214
	215	---
	216	-- curency-codes for Legic-Cash-Segments (ISO 4217)
	217	local currency = {
	218	["03d2"]="EUR",
	219	["0348"]="USD",
	220	["033A"]="GBP",
	221	["02F4"]="CHF"
	222	}
	223
	224	---
	225	-- This is only meant to be used when errors occur
	226	function oops(err)
	227	print(acred.."ERROR: "..acoff ,err)
	228	return nil, err
	229	end
	230
	231	---
	232	-- Usage help
	233	function help()
	234	print(desc)
	235	print("Version: "..version)
	236	print("Example usage: "..example)
	237	end
	238
	239	---
	240	-- table check helper
	241	function istable(t)
	242	return type(t) == 'table'
	243	end
	244
	245	---
	246	-- creates a 'deep copy' of a table (a=b only references)
	247	function deepCopy(object)
	248	local lookup_table = {}
	249	local function _copy(object)
	250	if type(object) ~= "table" then
	251	return object
	252	elseif lookup_table[object] then
	253	return lookup_table[object]
	254	end
	255	local new_table = {}
	256	lookup_table[object] = new_table
	257	for index, value in pairs(object) do
	258	new_table[_copy(index)] = _copy(value)
	259	end
	260	return setmetatable(new_table, getmetatable(object))
	261	end
	262	return _copy(object)
	263	end
	264
	265	---
	266	-- xor single byte
	267	function xorme(hex, xor, index)
	268	if ( index >= 23 ) then
	269	return ('%02x'):format(bxor( tonumber(hex,16) , tonumber(xor,16) ))
	270	else
	271	return hex
	272	end
	273	end
	274
	275	---
	276	-- (de)obfuscate bytes
	277	function xorBytes(inBytes, crc)
	278	local bytes = {}
	279	for index = 1, #inBytes do
	280	bytes[index] = xorme(inBytes[index], crc, index)
	281	end
	282	if (#inBytes == #bytes) then
	283	-- replace crc
	284	bytes[5] = string.sub(crc,-2)
	285	return bytes
	286	else
	287	print("error: byte-count missmatch")
	288	return false
	289	end
	290	end
	291
	292	---
	293	-- check availability of file
	294	function file_check(file_name)
	295	local file_found=io.open(file_name, "r")
	296	if file_found==nil then
	297	return false
	298	else
	299	return true
	300	end
	301	end
	302
	303	---
	304	-- split csv-string into table
	305	local function split(str, sep)
	306	local sep = sep or ','
	307	local fields={}
	308	local matchfunc = string.gmatch(str, "([^"..sep.."]+)")
	309	if not matchfunc then return {str} end
	310	for str in matchfunc do
	311	table.insert(fields, str)
	312	end
	313	return fields
	314	end
	315
	316	---
	317	-- put a string into a bytes-table
	318	function str2bytes(s)
	319	local res={}
	320	if (string.len(s)%2~=0) then return print("stamp should be a even hexstring e.g.: deadbeef or 0badc0de") end
	321	for i=1, string.len(s), 2 do
	322	table.insert(res, string.sub(s,i,(i+1)))
	323	end
	324	return res
	325	end
	326
	327	---
	328	-- put certain bytes into a new table
	329	function bytesToTable(bytes, bstart, bend)
	330	local t={}
	331	for i=0, (bend-bstart) do
	332	t[i]=bytes[bstart+i]
	333	end
	334	return t
	335	end
	336
	337	---
	338	-- read file into table
	339	function getInputBytes(infile)
	340	local line
	341	local bytes = {}
	342	local fhi,err = io.open(infile)
	343	if err then oops("faild to read from file ".. infile); return false; end
	344	while true do
	345	line = fhi:read()
	346	if line == nil then break end
	347	for byte in line:gmatch("%w+") do
	348	table.insert(bytes, byte)
	349	end
	350	end
	351	fhi:close()
	352	if (bytes[7]=='00') then return false end
	353	print(#bytes .. " bytes from "..infile.." loaded")
	354	return bytes
	355	end
	356
	357	---
	358	-- create tag-table helper
	359	function createTagTable()
	360	local t={
	361	['MCD'] = '00',
	362	['MSN0']= '11',
	363	['MSN1']= '22',
	364	['MSN2']= '33',
	365	['MCC'] = 'cc',
	366	['DCFl']= 'ff',
	367	['DCFh']= 'ff',
	368	['Type']= 'GAM',
	369	['OLE'] = 0,
	370	['Stamp_len']= 18,
	371	['WRP'] = '00',
	372	['WRC'] = '00',
	373	['RD'] = '00',
	374	['raw'] = '9f',
	375	['SSC'] = 'ff',
	376	['data']= {},
	377	['bck'] = {},
	378	['MTC'] = {},
	379	['SEG'] = {}
	380	}
	381	return t
	382	end
	383
	384	---
	385	-- put bytes into tag-table
	386	function bytesToTag(bytes, tag)
	387	if(istable(tag)) then
	388	tag.MCD =bytes[1];
	389	tag.MSN0=bytes[2];
	390	tag.MSN1=bytes[3];
	391	tag.MSN2=bytes[4];
	392	tag.MCC =bytes[5];
	393	tag.DCFl=bytes[6];
	394	tag.DCFh=bytes[7];
	395	tag.raw =bytes[8];
	396	tag.SSC =bytes[9];
	397	tag.Type=getTokenType(tag.DCFl);
	398	tag.OLE=bbit("0x"..tag.DCFl,7,1)
	399	tag.WRP=("%d"):format(bbit("0x"..bytes[8],0,4))
	400	tag.WRC=("%d"):format(bbit("0x"..bytes[8],4,3))
	401	tag.RD=("%d"):format(bbit("0x"..bytes[8],7,1))
	402	if (tag.Type=="SAM" and tag.raw=='9f') then
	403	tag.Stamp_len=(tonumber(0xfc,10)-tonumber(bbit("0x"..tag.DCFh,0,8),10))
	404	elseif (tag.Type=="SAM" and (tag.raw=='08' or tag.raw=='09')) then
	405	tag.Stamp_len = tonumber(tag.raw,10)
	406	end
	407	tag.data=bytesToTable(bytes, 10, 13)
	408	tag.Bck=bytesToTable(bytes, 14, 20)
	409	tag.MTC=bytesToTable(bytes, 21, 22)
	410
	411	print(acgreen.."Tag-Type: ".. tag.Type..acoff)
	412	if (tag.Type=="SAM" and #bytes>23) then
	413	tag=segmentsToTag(bytes, tag)
	414	print(acgreen..(#tag.SEG+1).." Segment(s) found"..acoff)
	415	-- unsegmented Master-Token
	416	-- only tag-data
	417	else
	418	for i=0, #tag.Bck do
	419	table.insert(tag.data, tag.Bck[i])
	420	end
	421	tag.data[#tag.data]=tag.MTC[0]
	422	tag.Bck=nil
	423	--tag.MTC[0]=tag.MTC[1]
	424	--tag.MTC[1]=nil
	425	end
	426	print(accyan..#bytes.." bytes for Tag processed"..acoff)
	427	return tag
	428	end
	429	return oops("tag is no table in: bytesToTag ("..type(tag)..")")
	430	end
	431
	432	---
	433	-- put segments from byte-table to tag-table
	434	function segmentsToTag(bytes, tag)
	435	if(#bytes>23) then
	436	local start=23
	437	local i=-1
	438	if (istable(tag)) then
	439	repeat
	440	i=i+1
	441	tag.SEG[i]=getSegmentData(bytes, start, ("%02d"):format(i))
	442	if (tag.Type=="SAM") then
	443	if (checkKghCrc(tag, i)) then tag.SEG[i].kgh=true end
	444	end
	445	start=start+tag.SEG[i].len
	446	until ((tag.SEG[i].valid==0) or tag.SEG[i].last==1 or i==126)
	447	return tag
	448	else return oops("tag is no table in: segmentsToTag ("..type(tag)..")") end
	449	else print("no Segments: must be a MIM22") end
	450	end
	451
	452	---
	453	-- read Tag-Table in bytes-table
	454	function tagToBytes(tag)
	455	if (istable(tag)) then
	456	local bytes = {}
	457	local i, i2
	458	-- main token-data
	459	table.insert(bytes, tag.MCD)
	460	table.insert(bytes, tag.MSN0)
	461	table.insert(bytes, tag.MSN1)
	462	table.insert(bytes, tag.MSN2)
	463	table.insert(bytes, tag.MCC)
	464	table.insert(bytes, tag.DCFl)
	465	table.insert(bytes, tag.DCFh)
	466	table.insert(bytes, tag.raw)
	467	table.insert(bytes, tag.SSC)
	468	-- raw token data
	469	for i=0, #tag.data do
	470	table.insert(bytes, tag.data[i])
	471	end
	472	-- backup data
	473	if(istable(tag.Bck)) then
	474	for i=0, #tag.Bck do
	475	table.insert(bytes, tag.Bck[i])
	476	end
	477	end
	478	-- token-create-time / master-token crc
	479	for i=0, #tag.MTC do
	480	table.insert(bytes, tag.MTC[i])
	481	end
	482	-- process segments
	483	if (type(tag.SEG[0])=='table') then
	484	for i=0, #tag.SEG do
	485	for i2=1, #tag.SEG[i].raw+1 do
	486	table.insert(bytes, #bytes+1, tag.SEG[i].raw[i2])
	487	end
	488	table.insert(bytes, #bytes+1, tag.SEG[i].crc)
	489	for i2=0, #tag.SEG[i].data-1 do
	490	table.insert(bytes, #bytes+1, tag.SEG[i].data[i2])
	491	end
	492	end
	493	end
	494	-- fill with zeros
	495	for i=#bytes+1, 1024 do
	496	table.insert(bytes, i, '00')
	497	end
	498	return bytes
	499	end
	500	return oops("tag is no table in tagToBytes ("..type(tag)..")")
	501	end
	502
	503	--- PM3 I/O ---
	504	---
	505	-- read from pm3 into virtual-tag
	506	function readFromPM3()
	507	local tag, bytes, infile
	508	infile="legic.temp"
	509	core.console("hf legic reader")
	510	core.console("hf legic save "..infile)
	511	tag=readFile(infile)
	512	return tag
	513	end
	514
	515	---
	516	-- write virtual Tag to real Tag
	517	function writeToTag(tag)
	518	local bytes
	519	local filename='MylegicClone.hex'
	520	local taglen=22
	521	if(utils.confirm(acred.."\nplace the (empty) Tag onto the PM3\nand confirm writing to this Tag: "..acoff) == false) then
	522	return
	523	end
	524	-- get used bytes / tag-len
	525	if(istable(tag.SEG)) then
	526	if (istable(tag.Bck)) then
	527	for i=0, #tag.SEG do
	528	taglen=taglen+tag.SEG[i].len+5
	529	end
	530	end
	531	local uid_old=tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2
	532	-- read new tag into memory so we can xor the new data with the new MCC
	533	outTAG=readFromPM3()
	534	outbytes=tagToBytes(outTAG)
	535	-- copy 'inputbuffer' to 'outputbuffer'
	536	tag.MCD = outbytes[1]
	537	tag.MSN0 = outbytes[2]
	538	tag.MSN1 = outbytes[3]
	539	tag.MSN2 = outbytes[4]
	540	tag.MCC = outbytes[5]
	541	-- recheck all segments-crc/kghcrc (only on a credential)
	542	if(istable(tag.Bck)) then
	543	checkAllSegCrc(tag)
	544	checkAllKghCrc(tag)
	545	local uid_new=tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2
	546	for i=0, #tag.SEG do
	547	if (check43rdPartyCash1(uid_old, tag.SEG[i].data)) then
	548	io.write(accyan.."\nfixing known checksums"..acoff.." ... ")
	549	if (fix3rdPartyCash1(uid_new, tag.SEG[i].data)) then
	550	io.write(acgreen.." done\n"..acoff)
	551	else oops("\nsomething went wrong at the repair of the 3rd-party-cash-segment") end
	552	end
	553	end
	554	end
	555	bytes=tagToBytes(tag)
	556	-- master-token-crc
	557	if (tag.Type~="SAM") then bytes[22]=calcMtCrc(bytes) end
	558	if (bytes) then
	559	print("write temp-file '"..filename.."'")
	560	print(accyan)
	561	writeFile(bytes, filename)
	562	--writeToTag(bytes, taglen, 'MylegicClone.hex')
	563	print(acoff)
	564	end
	565	end
	566	-- write data to file
	567	if (taglen > 0) then
	568	WriteBytes = utils.input(acyellow.."enter number of bytes to write?"..acoff, taglen)
	569	-- load file into pm3-buffer
	570	if (type(filename)~="string") then filename=input(acyellow.."filename to load to pm3-buffer?"..acoff,"legic.temp") end
	571	cmd = 'hf legic load '..filename
	572	core.console(cmd)
	573	-- write pm3-buffer to Tag
	574	for i=0, WriteBytes do
	575	if ( i<5 or i>6) then
	576	cmd = ('hf legic write 0x%02x 0x01'):format(i)
	577	core.console(cmd)
	578	--print(cmd)
	579	elseif (i == 6) then
	580	-- write DCF in reverse order (requires 'mosci-patch')
	581	cmd = 'hf legic write 0x05 0x02'
	582	print(acgreen..cmd..acoff)
	583	core.console(cmd)
	584	--print(cmd)
	585	else
	586	print(acgreen.."skip byte 0x05 - will be written next step"..acoff)
	587	end
	588	utils.Sleep(0.2)
	589	end
	590	end
	591	end
	592
	593	--- File I/O ---
	594	---
	595	-- read file into virtual-tag
	596	function readFile(filename)
	597	print(accyan)
	598	local bytes = {}
	599	local tag = {}
	600	if (file_check(filename)==false) then
	601	return oops("input file: "..filename.." not found")
	602	else
	603	bytes = getInputBytes(filename)
	604	if (bytes == false) then return oops('couldnt get input bytes')
	605	else
	606	-- make plain bytes
	607	bytes = xorBytes(bytes,bytes[5])
	608	print("create virtual tag from ".. #bytes .. " bytes")
	609	-- create Tag for plain bytes
	610	tag=createTagTable()
	611	-- load plain bytes to tag-table
	612	print(acoff)
	613	tag=bytesToTag(bytes, tag)
	614	end
	615	end
	616	return tag
	617	end
	618
	619	---
	620	-- write bytes to file
	621	function writeFile(bytes, filename)
	622	if (filename~='MylegicClone.hex') then
	623	if (file_check(filename)) then
	624	local answer = confirm("\nthe output-file "..filename.." alredy exists!\nthis will delete the previous content!\ncontinue?")
	625	if (answer==false) then return print("user abort") end
	626	end
	627	end
	628	local line
	629	local bcnt=0
	630	local fho,err = io.open(filename, "w")
	631	if err then oops("OOps ... faild to open output-file ".. filename) end
	632	bytes=xorBytes(bytes, bytes[5])
	633	for i = 1, #bytes do
	634	if (bcnt == 0) then
	635	line=bytes[i]
	636	elseif (bcnt <= 7) then
	637	line=line.." "..bytes[i]
	638	end
	639	if (bcnt == 7) then
	640	-- write line to new file
	641	fho:write(line.."\n")
	642	-- reset counter & line
	643	bcnt=-1
	644	line=""
	645	end
	646	bcnt=bcnt+1
	647	end
	648	fho:close()
	649	print("\nwrote ".. #bytes .." bytes to " .. filename)
	650	return true
	651	end
	652
	653	--- Map related ---
	654	---
	655	-- make tagMap
	656	function makeTagMap()
	657	local tagMap={}
	658	if (#tagMap==0) then
	659	tagMap['name']=input(accyan.."enter Name for this Map: "..acoff , "newTagMap")
	660	tagMap['mappings']={}
	661	tagMap['crc8']={}
	662	-- insert fixed Tag-CRC
	663	table.insert(tagMap.crc8, {name='TAG-CRC', pos=5, seq={1, 4}})
	664	tagMap['crc16']={}
	665	end
	666	print(accyan.."new tagMap created"..acoff)
	667	return tagMap
	668	end
	669
	670	---
	671	-- save mapping to file
	672	function saveTagMap(map, filename)
	673	if (string.len(filename)>0) then
	674	if (file_check(filename)) then
	675	local answer = confirm("\nthe output-file "..filename.." alredy exists!\nthis will delete the previous content!\ncontinue?")
	676	if (answer==false) then return print("user abort") end
	677	end
	678	end
	679
	680	local line
	681	local fho,err = io.open(filename, "w")
	682	if err then oops("OOps ... faild to open output-file ".. filename) end
	683
	684	-- write line to new file
	685	for k, v in pairs(map) do
	686	if (istable(v)) then
	687	for k2, v2 in pairs(v) do
	688	if (k=='mappings') then
	689	fho:write(k..","..k2..","..v2['name']..","..v2['start']..","..v2['end']..","..((v2['highlight']) and "1" or "0").."\n")
	690	elseif (k=="crc8") then
	691	local tmp=""
	692	tmp=k..","..k2..","..v2['name']..","..v2['pos']..","
	693	tmp=tmp..tbl2seqstr(v2['seq'])
	694	fho:write(tmp.."\n")
	695	end
	696	end
	697	else
	698	fho:write(k..","..v.."\n")
	699	end
	700	end
	701	fho:close()
	702	return true
	703	end
	704
	705	---
	706	-- toggle higligh
	707	function toggleHighlight(tbl)
	708	if (tbl['highlight']) then tbl['highlight']=false
	709	else tbl['highlight']=true end
	710	return tbl
	711	end
	712
	713	---
	714	-- return table od seqence-string
	715	function seqstr2tbl(seqstr)
	716	local s=split(seqstr)
	717	local res={}
	718	if (#s>=1) then
	719	for sk, sv in pairs(s) do
	720	s2=split(sv, '-')
	721	if(#s2==2) then
	722	table.insert(res, s2[1])
	723	table.insert(res, s2[2])
	724	end
	725	end
	726	end
	727	return res
	728	end
	729
	730	---
	731	-- return sequence-string from table
	732	function tbl2seqstr(seqtbl)
	733	local res=""
	734	if (istable(seqtbl)) then
	735	for sk, sv in pairs(seqtbl) do
	736	res=res..sv..((sk%2==0) and "," or "-")
	737	end
	738	if (string.sub(res, string.len(res))==",") then
	739	res=string.sub(res, 1, string.len(res)-1)
	740	end
	741	end
	742	return res
	743	end
	744
	745	---
	746	-- read map-file into map
	747	function loadTagMap(filename)
	748	local map={mappings={}, crc8={}, crc16={}}
	749	local m=0
	750	local c=0
	751	local line, fields
	752	local temp={}
	753	local offset=0
	754	if (file_check(filename)==false) then
	755	return oops("input file: "..filename.." not found")
	756	else
	757	local fhi,err = io.open(filename)
	758	while true do
	759	line = fhi:read()
	760	if line == nil then
	761	break
	762	else
	763	fields=split(line)
	764	end
	765	if (#fields==2) then
	766	if (fields[1]=='offset') then
	767	offset=tonumber(fields[2],10)
	768	end
	769	-- map-name
	770	map[fields[1]]=fields[2]
	771	elseif (fields[1]=='mappings') then
	772	m=m+1
	773	temp={}
	774	-- mapping
	775	temp['name']=fields[3]
	776	temp['start']=tonumber(fields[4], 10)
	777	temp['end']=tonumber(fields[5], 10)
	778	if(temp['start']>22) then
	779	temp['start']=temp['start']+offset
	780	temp['end']=temp['end']+offset
	781	end
	782	if (tonumber(fields[6], 10)==1) then temp['highlight']= true
	783	else temp['highlight']= false end
	784	table.insert(map['mappings'], m, temp)
	785	elseif (fields[1]=='crc8') then
	786	c=c+1
	787	temp={}
	788	-- crc8
	789	temp['name']=fields[3]
	790	temp['pos']=tonumber(fields[4], 10)+offset
	791	local s=string.sub(line, string.len(fields[1]..","..fields[2]..","..fields[3]..",")+1, string.len(line))
	792	temp['seq']=seqstr2tbl(s)
	793	for k, v in pairs(temp['seq']) do
	794	if(tonumber(v, 10)>22) then v=tonumber(v, 10)+offset end
	795	temp['seq'][k]=tonumber(v, 10)
	796	end
	797	table.insert(map.crc8, temp)
	798	end
	799	end
	800	fhi:close()
	801	end
	802	return map
	803	end
	804
	805	---
	806	-- dump tagMap (mappings only)
	807	function dumpTagMap(tag, tagMap)
	808	if(#tagMap.mappings>0) then
	809	bytes=tagToBytes(tag)
	810	local temp
	811	local lastend=0
	812	-- start display mappings
	813	for k, v in pairs(tagMap.mappings) do
	814	if ((lastend+1)<v['start']) then
	815	print("...")
	816	end
	817	if (isPosCrc8(tagMap, v['start'])>0) then
	818	if ( checkMapCrc8(tagMap, bytes, isPosCrc8(tagMap, v['start']) ) ) then
	819	io.write("("..("%04d"):format(v['start']).."-"..("%04d"):format(v['end'])..") "..acgreen..v['name']..acoff..":")
	820	else
	821	io.write("("..("%04d"):format(v['start']).."-"..("%04d"):format(v['end'])..") "..acred..v['name']..acoff..":")
	822	end
	823	else
	824	io.write("("..("%04d"):format(v['start']).."-"..("%04d"):format(v['end'])..") "..((v['highlight']) and acmagenta or acyellow)..v['name']..acoff..":")
	825	end
	826	temp=""
	827	for i=((string.len(v['name']))/10), 2 do
	828	temp=temp.."\t"
	829	end
	830	for i=v['start'], v['end'] do
	831	temp=temp..bytes[i].." "
	832	end
	833	print(temp)
	834	lastend=v['end']
	835	end
	836	end
	837	end
	838
	839	---
	840	--
	841	function isPosCrc8(tagMap, pos)
	842	local res=0
	843	if (#tagMap.crc8>0) then
	844	for k, v in pairs(tagMap.crc8) do
	845	if(v['pos']==pos) then res=k end
	846	end
	847	end
	848	return res
	849	end
	850
	851	---
	852	-- check mapped crc
	853	function checkMapCrc8(tagMap, bytes, n)
	854	local res=false
	855	if (#tagMap.crc8>0) then
	856	if(istable(tagMap.crc8[n])) then
	857	temp=""
	858	for k2, v2 in pairs(tagMap.crc8[n]) do
	859	if (istable(v2)) then
	860	temp=temp..tbl2seqstr(v2)
	861	end
	862	end
	863	local tempres=""
	864	local tempres=getSequences(bytes, temp)
	865	tempres=("%02x"):format(utils.Crc8Legic(tempres))
	866	if (bytes[tagMap.crc8[n]['pos']]==tempres) then
	867	res=true
	868	end
	869	end
	870	end
	871	return res
	872	end
	873
	874	---
	875	-- edit existing Map
	876	function editTagMap(tag, tagMap)
	877	local t = [[
	878	Data: dm = show dr = dump raw
	879	Mappings: im = insert am = add rm = remove
	880	CRC8: ac8 = add sc8 = show rc8 = remove
	881	: q = exit h = Help
	882	]]
	883	--if(#tagMap.mappings==0) then oops("no mappings in tagMap"); return tagMap end
	884	print("tagMap edit-mode submenu")
	885	repeat
	886	x=input('tagMap submenu:', 'h')
	887	if (x=='h') then print(t)
	888	elseif (x=='dm') then tagMmap=dumpTagMap(tag, tagMap)
	889	elseif (x=='dr') then tagMmap=dumpMap(tag, tagMap)
	890	elseif (x=='rc8') then
	891	if (istable(tagMap.crc8)) then
	892	local x1 = selectTableEntry(tagMap.crc8, "select number of CRC8 to remove:")
	893	if (istable(tagMap.crc8[x1])) then
	894	table.remove(tagMap.crc8, x1)
	895	end
	896	end
	897	elseif (x=='ac8') then
	898	local p=tonumber(input("enter byte-addr of crc8", '0'),10)
	899	if (p>0) then
	900	local i1=input("enter comma-seperated byte-sequences (e.g.: '1-4,23-26')", '1-4,23-26')
	901	local s1=split(i1, ',')
	902	if (#s1>0) then
	903	local temp={seq={}}
	904	for k, v in pairs(s1) do
	905	v1=split(v, '-')
	906	if(#v1==2) then
	907	table.insert(temp.seq, v1[1])
	908	table.insert(temp.seq, v1[2])
	909	end
	910	end
	911	temp['pos']=p
	912	temp['name']=input("enter a name for the CRC8", "CRC "..(#tagMap.crc8+1))
	913	table.insert(tagMap.crc8, temp)
	914	end
	915	end
	916	elseif (string.sub(x, 1, 3)=='sc8') then
	917	local bytes=tagToBytes(tag)
	918	local res, pos
	919	-- trigger manually by sc8 <'4digit' checkadd> <'seqeuence-string'>
	920	-- e.g.: sc8 0027 1-4,23-36
	921	if (string.len(x)>=9) then
	922	pos=tonumber(string.sub(x, 5, 8), 10)
	923	x=string.sub(x, 9, string.len(x))
	924	print("x: "..x.." - pos:"..pos)
	925	else
	926	x=selectTableEntry(tagMap.crc8, "select CRC:")
	927	if(istable(tagMap.crc8[x])) then
	928	pos=tagMap.crc8[x]['pos']
	929	x=tbl2seqstr(tagMap.crc8[x]['seq'])
	930	end
	931	end
	932	if (type(x)=='string') then
	933	res=("%02x"):format(utils.Crc8Legic(getSequences(bytes, x)))
	934	print(accyan.."Sequence:\t"..acoff..x)
	935	print(accyan.."Bytes:\t\t"..acoff..getSequences(bytes, x))
	936	print(accyan.."calculated: "..acoff..res..accyan.." bytes["..pos.."]: "..acoff..bytes[pos].." ("..compareCrc(utils.Crc8Legic(getSequences(bytes, x)), bytes[pos])..")")
	937	end
	938	elseif (x=="tm") then
	939	x=selectTableEntry(tagMap.mappings, "select number of Mapping:")
	940	tagMap.mappings[x]=toggleHighlight(tagMap.mappings[x])
	941	elseif (x=='am') then tagMap=addMapping(tag, tagMap)
	942	elseif (x=='im') then tagMap=addMapping(tag, tagMap, selectTableEntry(tagMap.mappings, "select List-Position for insert:"))
	943	elseif (x=='rm') then tagMap=deleteMapping(tag, tagMap)
	944	elseif (x=='mas') then tagMap=mapTag(tagMap); tagMap=mapAllSegments(tag, tagMap)
	945	elseif (type(actions[string.sub(x, 3)])=='function') then actions[string.sub(x, 3)]()
	946	end
	947	until x=='q'
	948	print("exit sub-Menu")
	949	return tagMap
	950	end
	951
	952	---
	953	-- dump raw mapped and unmapped
	954	function dumpMap(tag, tagMap)
	955	local dstart=1
	956	local dend, cnt
	957	local bytes = tagToBytes(tag)
	958	local stats = getSegmentStats(bytes)
	959	dend=stats[#stats]['end']
	960	print(accyan.."Tag uses "..dend.." bytes:"..acoff)
	961	for i=dstart, dend do
	962	if (check4MappedByte(i, tagMap) and not check4MapCrc8(i, tagMap) and not check4Highlight(i, tagMap)) then io.write(""..acyellow)
	963	elseif (check4MapCrc8(i, tagMap)) then
	964	if ( checkMapCrc8(tagMap, bytes, isPosCrc8(tagMap, i) ) ) then
	965	io.write(""..acgreen)
	966	else
	967	io.write(""..acred)
	968	end
	969	else
	970	io.write(""..acoff)
	971	end
	972	-- highlighted mapping
	973	if (check4Highlight(i, tagMap)) then io.write(""..acmagenta) end
	974
	975	io.write(bytes[i])
	976	if (i%8==0) then io.write("\n")
	977	else io.write(" ") end
	978	end
	979
	980	io.write("\n"..acoff)
	981	end
	982
	983	---
	984	-- show bytes used for crc-calculation
	985	function getSequences(bytes, seqstr)
	986	if (type(seqstr)~="string") then seqstr=input("enter comma-seperated sequences (e.g.: '1-4,23-26')", '1-4,23-26') end
	987	local seqs=split(seqstr, ',')
	988	local res = ""
	989	if(#seqs>0) then
	990	for k, v in pairs(seqs) do
	991	local seq = split(v,'-')
	992	if (#seq>=2) then
	993	for i=seq[1], seq[2] do
	994	res=res..bytes[i].." "
	995	end
	996	end
	997	if(string.len(res)>0) then res=res.." " end
	998	end
	999	else
	1000	oops("no sequence found in '"..seqstr.."'")
	1001	end
	1002	return res
	1003	end
	1004
	1005	---
	1006	-- check if byte-addr is a know crc
	1007	function check4MapCrc8(addr, tagMap)
	1008	local res=false
	1009	for i=1, #tagMap.crc8 do
	1010	if (addr == tagMap.crc8[i]['pos']) then
	1011	res=true
	1012	end
	1013	end
	1014	return res
	1015	end
	1016
	1017	---
	1018	-- check if byte-addr is a know crc
	1019	function check4MapCrc16(addr, tagMap)
	1020	local res=false
	1021	for i=1, #tagMap.crc16 do
	1022	if (addr == tagMap.crc16[i]['pos']) then
	1023	res=true
	1024	end
	1025	end
	1026	return res
	1027	end
	1028
	1029	---
	1030	-- check if byte is mapped or not
	1031	function check4MappedByte(addr, tagMap)
	1032	local res=false
	1033	for _, v in pairs(tagMap.mappings) do
	1034	if (addr >= v['start'] and addr <= v['end'] ) then
	1035	res= true
	1036	end
	1037	end
	1038	return res
	1039	end
	1040
	1041	---
	1042	-- check if byte is highlighted or not
	1043	function check4Highlight(addr, tagMap)
	1044	local res=false
	1045	for _, v in pairs(tagMap.mappings) do
	1046	if (addr >= v['start'] and addr <= v['end'] ) then
	1047	res= v['highlight']
	1048	end
	1049	end
	1050	return res
	1051	end
	1052
	1053	---
	1054	-- add interactive mapping
	1055	function addMapping(tag, tagMap, x)
	1056	if (type(x)~="number") then x=#tagMap.mappings+1 end
	1057	local bytes=tagToBytes(tag)
	1058	local myMapping={}
	1059	myMapping['name'] =input(accyan.."enter Maping-Name:"..acoff, string.format("mapping %d", #tagMap.mappings+1))
	1060	myMapping['start']=tonumber(input(accyan.."enter start-addr:"..acoff, '1'), 10)
	1061	myMapping['end'] =tonumber(input(accyan.."enter end-addr:"..acoff, #bytes), 10)
	1062	myMapping['highlight']=confirm("set highlighted")
	1063	table.insert(tagMap.mappings, x, myMapping)
	1064	return tagMap
	1065	end
	1066
	1067	---
	1068	-- delete mapping
	1069	function deleteMapping(tag, tagMap)
	1070	if(#tagMap.mappings>0) then
	1071	local d = selectTableEntry(tagMap.mappings, "select number of Mapping to remove:")
	1072	if (type(d)=='number') then
	1073	table.remove(tagMap.mappings, d)
	1074	else oops("deleteMapping: got type = "..type(d).." - expected type = 'number'")
	1075	end
	1076	end
	1077	return tagMap
	1078	end
	1079
	1080	---
	1081	-- select a mapping from a tagmap
	1082	function selectTableEntry(table, action)
	1083	if (type(action)~="string") then action="select number of item:" end
	1084	for k, v in pairs(table) do
	1085	print(accyan..k..acoff.."\t-> "..accyan..v['name']..acoff)
	1086	end
	1087	local res = tonumber(input(action , 0), 10)
	1088	if (istable(table[res])) then
	1089	return res
	1090	else
	1091	return false
	1092	end
	1093	end
	1094
	1095	---
	1096	-- map all segments
	1097	function mapAllSegments(tag, tagMap)
	1098	local bytes=tagToBytes(tag)
	1099	local WRP,WRC,WRPC
	1100	segs=getSegmentStats(bytes)
	1101	if (istable(segs)) then
	1102	for k, v in pairs(segs) do
	1103	-- wrp (write proteted) = byte 2
	1104	WRP = tonumber(bytes[v['start']+2],16)
	1105	-- wrc (write control) - bit 4-6 of byte 3
	1106	WRC = tonumber(bbit("0x"..bytes[v['start']+3],4,3),16)
	1107	--tagMap=mapTokenData(tagMap, 'Segment '..("%02d"):format(v['index']).." HDR", v['start'], v['start']+3)
	1108	tagMap=mapTokenData(tagMap, 'Segment '..("%02d"):format(v['index']).." CRC", v['start']+4, v['start']+4, true)
	1109	table.insert(tagMap.crc8, {name = 'Segment '..("%02d"):format(v['index']).." CRC", pos=v['start']+4, seq={1,4,v['start'],v['start']+3}} )
	1110	if(WRC>WRP) then
	1111	WRPC=WRC
	1112	tagMap=mapTokenData(tagMap, 'Segment '..("%02d"):format(v['index']).." WRC", v['start']+5, v['start']+5+WRC-1, true)
	1113	elseif (WRP>WRC and WRC>0) then
	1114	WRPC=WRP
	1115	tagMap=mapTokenData(tagMap, 'Segment '..("%02d"):format(v['index']).." WRC", v['start']+5, v['start']+5+WRC-1, true)
	1116	tagMap=mapTokenData(tagMap, 'Segment '..("%02d"):format(v['index']).." WRP", v['start']+WRC+5, v['start']+5+WRP-1, true)
	1117	else
	1118	WRPC=WRP
	1119	tagMap=mapTokenData(tagMap, 'Segment '..("%02d"):format(v['index']).." WRP", v['start']+5, v['start']+5+WRP-1, true)
	1120	end
	1121	tagMap=mapTokenData(tagMap, 'Segment '..("%02d"):format(v['index']).." data", v['start']+5+WRPC, v['end'], false)
	1122
	1123	end
	1124	print(#segs.." Segments mapped")
	1125	else
	1126	oops("autoMapSegments failed: no Segments found")
	1127	end
	1128	return tagMap
	1129	end
	1130
	1131	---
	1132	-- map all token data
	1133	function mapTokenData(tagMap, mname, mstart, mend, mhigh)
	1134	--if ( not mhigh ) then mhigh=false end
	1135	local myMapping={}
	1136	myMapping['name'] =mname
	1137	myMapping['start']=mstart
	1138	myMapping['end'] =mend
	1139	myMapping['highlight']=mhigh
	1140	table.insert(tagMap.mappings, myMapping)
	1141	return tagMap
	1142	end
	1143
	1144	---
	1145	-- map a map
	1146	function mapTag(tagMap)
	1147	tagMap=makeTagMap()
	1148	tagMap=mapTokenData(tagMap, 'Tag-ID', 1, 4, true)
	1149	tagMap=mapTokenData(tagMap, 'Tag-CRC', 5, 5, false)
	1150	tagMap=mapTokenData(tagMap, 'DCF', 6, 7, true)
	1151	tagMap=mapTokenData(tagMap, 'THDR-Raw/Stamp-Len', 8, 8, true)
	1152	tagMap=mapTokenData(tagMap, 'SSC', 9, 9, true)
	1153	tagMap=mapTokenData(tagMap, 'Header', 10, 13, false)
	1154	tagMap=mapTokenData(tagMap, 'Backup', 14, 19, true)
	1155	tagMap=mapTokenData(tagMap, 'Bck-CRC', 20, 20, false)
	1156	tagMap=mapTokenData(tagMap, 'TokenTime', 21, 22, false)
	1157	return tagMap
	1158	end
	1159
	1160	--- Dump Data ---
	1161	---
	1162	-- dump virtual Tag-Data
	1163	function dumpTag(tag)
	1164	local i, i2
	1165	local res
	1166	local dp=0
	1167	local raw=""
	1168	-- sytstem area
	1169	res =acyellow.."\nCDF: System Area"..acoff
	1170	res= res.."\n"..dumpCDF(tag)
	1171	-- segments (user-token area)
	1172	if(tag.Type=="SAM" and tag.raw=='9f') then
	1173	res = res..acyellow.."\n\nADF: User Area"..acoff
	1174	for i=0, #tag.SEG do
	1175	res=res.."\n"..dumpSegment(tag, i).."\n"
	1176	end
	1177	end
	1178	return res
	1179	end
	1180
	1181	---
	1182	-- dump tag-system area
	1183	function dumpCDF(tag)
	1184	local res=""
	1185	local i=0
	1186	local raw=""
	1187	local bytes
	1188	if (istable(tag)) then
	1189	res = res..accyan.."MCD: "..acoff..tag.MCD..accyan.." MSN: "..acoff..tag.MSN0.." "..tag.MSN1.." "..tag.MSN2..accyan.." MCC: "..acoff..tag.MCC.."\n"
	1190	res = res.."DCF: "..tag.DCFl.." "..tag.DCFh..", Token_Type="..tag.Type.." (OLE="..tag.OLE.."), Stamp_len="..tag.Stamp_len.."\n"
	1191	res = res.."WRP="..tag.WRP..", WRC="..tag.WRC..", RD="..tag.RD..", raw="..tag.raw..((tag.raw=='9f') and (", SSC="..tag.SSC.."\n") or "\n")
	1192
	1193	-- credential (end-user tag)
	1194	if (tag.Type=="SAM" and tag.raw=='9f') then
	1195	res = res.."Remaining Header Area\n"
	1196	for i=0, (#tag.data) do
	1197	res = res..tag.data[i].." "
	1198	end
	1199	res = res.."\nBackup Area\n"
	1200	for i=0, (#tag.Bck) do
	1201	res = res..tag.Bck[i].." "
	1202	end
	1203	res = res.."\nTime Area\n"
	1204	for i=0, (#tag.MTC) do
	1205	res = res..tag.MTC[i].." "
	1206	end
	1207
	1208
	1209	-- Master Token specific
	1210	elseif (tag.Type~="SAM") then
	1211	res = res .."Master-Token Area\nStamp: "
	1212	res= res..tag.SSC.." "
	1213	for i=0, tag.Stamp_len-2 do
	1214	res = res..tag.data[i].." "
	1215	end
	1216	res=res.."\nunused payload\n"
	1217	for i=0, (#tag.data-tag.Stamp_len-1) do
	1218	res = res..tag.data[i].." "
	1219	end
	1220	bytes=tagToBytes(tag)
	1221	local mtcrc=calcMtCrc(bytes)
	1222	res=res.."\nMaster-Token CRC: "
	1223	res = res ..tag.MTC[1].." ("..((tag.MTC[1]==mtcrc) and "valid" or "error")..")"
	1224
	1225
	1226	-- 'Gantner User-Credential' specific
	1227	elseif (tag.Type=="SAM" and (tag.raw=='08' or tag.raw=='09')) then
	1228	print(acgreen.."Gantner Detected"..acoff)
	1229	end
	1230
	1231	return res
	1232	else print("no valid Tag in dumpCDF") end
	1233	end
	1234
	1235	---
	1236	-- dump single segment
	1237	function dumpSegment(tag, index)
	1238	local i=index
	1239	local i2
	1240	local dp=0 --data-position in table
	1241	local res="" --result
	1242	local raw="" --raw-header
	1243	-- segment
	1244	if ( (istable(tag.SEG[i])) and tag.Type=="SAM" and tag.raw=="9f") then
	1245	if (istable(tag.SEG[i].raw)) then
	1246	for k,v in pairs(tag.SEG[i].raw) do
	1247	raw=raw..v.." "
	1248	end
	1249	end
	1250
	1251	-- segment header
	1252	res = res..accyan.."Segment "..("%02d"):format(tag.SEG[i].index)..acoff..": "
	1253	res = res .."raw header: "..string.sub(raw,0,-2)..", flag="..tag.SEG[i].flag..", (valid="..("%x"):format(tag.SEG[i].valid)..", last="..("%x"):format(tag.SEG[i].last).."), "
	1254	res = res .."len="..("%04d"):format(tag.SEG[i].len)..", WRP="..("%02x"):format(tag.SEG[i].WRP)..", WRC="..("%02x"):format(tag.SEG[i].WRC)..", "
	1255	res = res .."RD="..("%02x"):format(tag.SEG[i].RD)..", CRC="..tag.SEG[i].crc.." "
	1256	res = res .."("..(checkSegmentCrc(tag, i) and acgreen.."valid" or acred.."error") ..acoff..")"
	1257	raw=""
	1258
	1259
	1260	-- WRC protected
	1261	if ((tag.SEG[i].WRC>0)) then
	1262	res = res .."\nWRC protected area:\n"
	1263	for i2=dp, dp+tag.SEG[i].WRC-1 do
	1264	res = res..tag.SEG[i].data[i2].." "
	1265	dp=dp+1
	1266	end
	1267	end
	1268
	1269	-- WRP mprotected
	1270	if (tag.SEG[i].WRP>tag.SEG[i].WRC) then
	1271	res = res .."\nRemaining write protected area:\n"
	1272	for i2=dp, dp+(tag.SEG[i].WRP-tag.SEG[i].WRC)-1 do
	1273	res = res..tag.SEG[i].data[i2].." "
	1274	dp=dp+1
	1275	end
	1276	end
	1277
	1278	-- payload
	1279	if (#tag.SEG[i].data-dp>0) then
	1280	res = res .."\nRemaining segment payload:\n"
	1281	for i2=dp, #tag.SEG[i].data-2 do
	1282	res = res..tag.SEG[i].data[dp].." "
	1283	dp=dp+1
	1284	end
	1285	if (tag.SEG[i].kgh) then
	1286	res = res..tag.SEG[i].data[dp].." (KGH: "..(checkKghCrc(tag, i) and acgreen.."valid" or acred.."error") ..acoff..")"
	1287	else res = res..tag.SEG[i].data[dp] end
	1288	end
	1289	dp=0
	1290	return res
	1291	else
	1292	return print("Segment not found")
	1293	end
	1294	end
	1295
	1296	---
	1297	-- return bytes 'sstrat' to 'send' from a table
	1298	function dumpTable(tab, header, tstart, tend)
	1299	res=""
	1300	for i=tstart, tend do
	1301	res=res..tab[i].." "
	1302	end
	1303	if (string.len(header)==0) then return res
	1304	else return (header.." #"..(tend-tstart+1).."\n"..res) end
	1305	end
	1306
	1307	---
	1308	-- dump 3rd Party Cash
	1309	function dump3rdPartyCash1(tag , seg)
	1310	local uid=tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2
	1311	local stamp=tag.SEG[seg].data[0].." "..tag.SEG[seg].data[1].." "..tag.SEG[seg].data[2]
	1312	local datastamp=tag.SEG[seg].data[20].." "..tag.SEG[seg].data[21].." "..tag.SEG[seg].data[22]
	1313	local balance=tonumber(tag.SEG[seg].data[32]..tag.SEG[seg].data[33] ,16)
	1314	local balancecrc=utils.Crc8Legic(uid..tag.SEG[seg].data[32]..tag.SEG[seg].data[33])
	1315	local mirror=tonumber(tag.SEG[seg].data[35]..tag.SEG[seg].data[36] ,16)
	1316	local mirrorcrc=utils.Crc8Legic(uid..tag.SEG[seg].data[35]..tag.SEG[seg].data[36])
	1317	local lastbal0=tonumber(tag.SEG[seg].data[39]..tag.SEG[seg].data[40] ,16)
	1318	local lastbal1=tonumber(tag.SEG[seg].data[41]..tag.SEG[seg].data[42] ,16)
	1319	local lastbal2=tonumber(tag.SEG[seg].data[43]..tag.SEG[seg].data[44] ,16)
	1320
	1321	test=""
	1322	-- display decoded/known stuff
	1323	print("\n------------------------------")
	1324	print("Tag-ID:\t\t "..uid)
	1325	print("Stamp:\t\t "..stamp)
	1326	print("UID-Mapping: \t\t"..("%06d"):format(tonumber(tag.SEG[seg].data[46]..tag.SEG[seg].data[47]..tag.SEG[seg].data[48], 16)))
	1327	print("------------------------------")
	1328	print("checksum 1:\t\t "..tag.SEG[seg].data[31].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[seg].data, "", 19, 30)), tag.SEG[seg].data[31])..")")
	1329	print("checksum 2:\t\t "..tag.SEG[seg].data[34].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[seg].data, "", 32, 33)), tag.SEG[seg].data[34])..")")
	1330	print("checksum 3:\t\t "..tag.SEG[seg].data[37].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[seg].data, "", 35, 36)), tag.SEG[seg].data[37])..")")
	1331
	1332	print("checksum 4:\t\t "..tag.SEG[seg].data[55].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[seg].data, "", 46, 54)), tag.SEG[seg].data[55])..")")
	1333	print("checksum 5:\t\t "..tag.SEG[seg].data[62].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[seg].data, "", 56, 61)), tag.SEG[seg].data[62])..")")
	1334	print("checksum 6:\t\t "..tag.SEG[seg].data[73].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[seg].data, "", 63, 72)), tag.SEG[seg].data[73])..")")
	1335	print("checksum 7:\t\t "..tag.SEG[seg].data[89].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[seg].data, "", 74, 88)), tag.SEG[seg].data[89])..")")
	1336	print("------------------------------")
	1337	print(string.format("Balance:\t\t %3.2f", balance/100).." ".."("..compareCrc(balancecrc, tag.SEG[seg].data[34])..")")
	1338	print(string.format("Shadow:\t\t\t %3.2f", mirror/100).." ".."("..compareCrc(balancecrc, tag.SEG[seg].data[37])..")")
	1339	print("------------------------------")
	1340	print(string.format("History 1:\t\t %3.2f", lastbal0/100))
	1341	print(string.format("History 2:\t\t %3.2f", lastbal1/100))
	1342	print(string.format("History 3:\t\t %3.2f", lastbal2/100))
	1343	print("------------------------------\n")
	1344	end
	1345
	1346	---
	1347	-- dump Legic-Cash data
	1348	function dumpLegicCash(tag, x)
	1349	if (istable(tag.SEG[x])) then
	1350	io.write("in Segment "..tag.SEG[x].index.." :\n")
	1351	print("--------------------------------\n\tLegic-Cash Values\n--------------------------------")
	1352	local limit, curr, balance, rid, tcv
	1353	-- currency of balance & limit
	1354	curr=currency[tag.SEG[x].data[8]..tag.SEG[x].data[9]]
	1355	-- maximum balance
	1356	limit=string.format("%4.2f", tonumber(tag.SEG[x].data[10]..tag.SEG[x].data[11]..tag.SEG[x].data[12], 16)/100)
	1357	-- current balance
	1358	balance=string.format("%4.2f", tonumber(tag.SEG[x].data[15]..tag.SEG[x].data[16]..tag.SEG[x].data[17], 16)/100)
	1359	-- reader-id who wrote last transaction
	1360	rid=tonumber(tag.SEG[x].data[18]..tag.SEG[x].data[19]..tag.SEG[x].data[20], 16)
	1361	-- transaction counter value
	1362	tcv=tonumber(tag.SEG[x].data[29], 16)
	1363	print("Currency:\t\t "..curr)
	1364	print("Limit:\t\t\t "..limit)
	1365	print("Balance:\t\t "..balance)
	1366	print("Transaction Counter:\t "..tcv)
	1367	print("Reader-ID:\t\t "..rid.."\n--------------------------------\n")
	1368	end
	1369	end
	1370
	1371	---
	1372	-- raw 3rd-party
	1373	function print3rdPartyCash1(tag, x)
	1374	if (istable(tag.SEG[x])) then
	1375	local uid=tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2
	1376	print("\n\t\tStamp : "..dumpTable(tag.SEG[x].data, "", 0 , 2))
	1377	print("\t\tBlock 0: "..dumpTable(tag.SEG[x].data, "", 3 , 18))
	1378	print()
	1379	print("\t\tBlock 1: "..dumpTable(tag.SEG[x].data, "", 19, 30))
	1380	print("checksum 1: Tag-ID .. Block 1 => LegicCrc8 = "..tag.SEG[x].data[31].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[x].data, "", 19, 30)), tag.SEG[x].data[31])..")")
	1381	print()
	1382	print("\t\tBlock 2: "..dumpTable(tag.SEG[x].data, "", 32, 33))
	1383	print("checksum 2: Block 2 => LegicCrc8 = "..tag.SEG[x].data[34].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[x].data, "", 32, 33)), tag.SEG[x].data[34])..")")
	1384	print()
	1385	print("\t\tBlock 3: "..dumpTable(tag.SEG[x].data, "", 35, 36))
	1386	print("checksum 3: Block 3 => LegicCrc8 = "..tag.SEG[x].data[37].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[x].data, "", 35, 36)), tag.SEG[x].data[37])..")")
	1387	print()
	1388	print("\t\tyet unknown: "..tag.SEG[x].data[38])
	1389	print()
	1390	print("\t\tHisatory 1: "..dumpTable(tag.SEG[x].data, "", 39, 40))
	1391	print("\t\tHisatory 2: "..dumpTable(tag.SEG[x].data, "", 41, 42))
	1392	print("\t\tHisatory 3: "..dumpTable(tag.SEG[x].data, "", 43, 44))
	1393	print()
	1394	print("\t\tyet unknown: "..tag.SEG[x].data[45])
	1395	print()
	1396	print("\t\tKGH-UID HEX: "..dumpTable(tag.SEG[x].data, "", 46, 48))
	1397	print("\t\tBlock 4: "..dumpTable(tag.SEG[x].data, "", 49, 54))
	1398	print("checksum 4: Tag-ID .. KGH-UID .. Block 4 => LegicCrc8 = "..tag.SEG[x].data[55].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[x].data, "", 46, 54)), tag.SEG[x].data[55])..")")
	1399	print()
	1400	print("\t\tBlock 5: "..dumpTable(tag.SEG[x].data, "", 56, 61))
	1401	print("checksum 5: Tag-ID .. Block 5 => LegicCrc8 = "..tag.SEG[x].data[62].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[x].data, "", 56, 61)), tag.SEG[x].data[62])..")")
	1402	print()
	1403	print("\t\tBlock 6: "..dumpTable(tag.SEG[x].data, "", 63, 72))
	1404	print("checksum 6: Tag-ID .. Block 6 => LegicCrc8 = "..tag.SEG[x].data[73].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[x].data, "", 63, 72)), tag.SEG[x].data[73])..")")
	1405	print()
	1406	print("\t\tBlock 7: "..dumpTable(tag.SEG[x].data, "", 74, 88))
	1407	print("checksum 7: Tag-ID .. Block 7 => LegicCrc8 = "..tag.SEG[x].data[89].." ("..compareCrc(utils.Crc8Legic(uid..dumpTable(tag.SEG[x].data, "", 74, 88)), tag.SEG[x].data[89])..")")
	1408	print()
	1409	print("\t\tBlock 8: "..dumpTable(tag.SEG[x].data, "", 90, 94))
	1410	end
	1411	end
	1412
	1413	--- Token related --
	1414	---
	1415	-- make token
	1416	function makeToken()
	1417	local mt={
	1418	['Type'] = {"SAM", "SAM63", "SAM64", "IAM", "GAM"},
	1419	['DCF'] = {"60ea", "31fa", "30fa", "80fa", "f0fa"},
	1420	['WRP'] = {"15", "2", "2", "2", "2"},
	1421	['WRC'] = {"01", "02", "02", "00", "00"},
	1422	['RD'] = {"01", "00", "00", "00", "00"},
	1423	['Stamp'] = {"00", "00", "00", "00", "00"},
	1424	['Segment'] = {"0d", "c0", "04", "00", "be", "01", "02", "03", "04", "01", "02", "03", "04"}
	1425	}
	1426	ttype=""
	1427	for k, v in pairs(mt.Type) do
	1428	ttype=ttype..k..") "..v.." "
	1429	end
	1430	mtq=tonumber(input("select number for Token-Type\n"..ttype, '1'), 10)
	1431	if (type(mtq)~="number") then return print("selection invalid!")
	1432	elseif (mtq>#mt.Type) then return print("selection invalid!")
	1433	else print("Token-Type '"..mt.Type[mtq].."' selected") end
	1434	local raw=calcHeaderRaw(mt.WRP[mtq], mt.WRC[mtq], mt.RD[mtq])
	1435	local mtCRC="00"
	1436
	1437	bytes={"01", "02", "03", "04", "cb", string.sub(mt.DCF[mtq], 0, 2), string.sub(mt.DCF[mtq], 3), raw,
	1438	"00", "00", "00", "00", "00", "00", "00", "00",
	1439	"00", "00", "00", "00", "00", "00"}
	1440	if (mtq==1) then
	1441	for i=0, #mt.Segment do
	1442	table.insert(bytes, mt.Segment[i])
	1443	end
	1444	bytes[9]="ff"
	1445	end
	1446	-- fill bytes
	1447	for i=#bytes, 1023 do table.insert(bytes, "00") end
	1448	-- if Master-Token -> calc Master-Token-CRC
	1449	if (mtq>1) then bytes[22]=calcMtCrc(bytes) end
	1450	local tempTag=createTagTable()
	1451	-- remove segment if MasterToken
	1452	if (mtq>1) then tempTag.SEG[0]=nil end
	1453	return bytesToTag(bytes, tempTag)
	1454	end
	1455
	1456	---
	1457	-- edit token-data
	1458	function editTag(tag)
	1459	-- for simulation it makes sense to edit everything
	1460	local edit_sim="MCD MSN0 MSN1 MSN2 MCC DCFl DCFh WRP WRC RD"
	1461	-- on real tags it makes only sense to edit DCF, WRP, WRC, RD
	1462	local edit_real="DCFl DCFh WRP WRC RD"
	1463	if (confirm(acyellow.."do you want to edit non-writeable values (e.g. for simulation)?"..acoff)) then
	1464	edit_tag=edit_sim
	1465	else edit_tag=edit_real end
	1466
	1467	if(istable(tag)) then
	1468	for k,v in pairs(tag) do
	1469	if(type(v)~="table" and type(v)~="boolean" and string.find(edit_tag, k)) then
	1470	tag[k]=input("value for: "..accyan..k..acoff, v)
	1471	end
	1472	end
	1473
	1474	if (tag.Type=="SAM") then ttype="Header"; else ttype="Stamp"; end
	1475	if (confirm(acyellow.."do you want to edit "..ttype.." Data?"..acoff)) then
	1476	-- master-token specific
	1477	if(istable(tag.Bck)==false) then
	1478	-- stamp-data length=(0xfc-DCFh)
	1479	-- on MT: SSC holds the Starting Stamp Character (Stamp0)
	1480	tag.SSC=input(ttype.."0: ", tag.SSC)
	1481	-- rest of stamp-bytes are in tag.data 0..n
	1482	for i=0, (tonumber(0xfc ,10)-("%d"):format('0x'..tag.DCFh))-2 do
	1483	tag.data[i]=input(ttype.. i+1 ..": ", tag.data[i])
	1484	end
	1485	else
	1486	--- on credentials byte7 should always be 9f and byte8 ff
	1487	-- on Master-Token not (even on SAM63/64 not)
	1488	-- tag.SSC=input(ttype.."0: ", tag.SSC)
	1489	for i=0, #tag.data do
	1490	tag.data[i]=input(ttype.. i ..": ", tag.data[i])
	1491	end
	1492	end
	1493	end
	1494
	1495	bytes=tagToBytes(tag)
	1496
	1497	--- check data-consistency (calculate tag.raw)
	1498	bytes[8]=calcHeaderRaw(tag.WRP, tag.WRC, tag.RD)
	1499
	1500	--- Master-Token specific
	1501	-- should be triggered if a SAM was converted to a non-SAM (user-Token to Master-Token)
	1502	-- or a Master-Token has being edited (also SAM64 & SAM63 - which are in fact Master-Token)
	1503	if(tag.Type~="SAM" or bytes[6]..bytes[7]~="60ea") then
	1504	-- calc new Master-Token crc
	1505	bytes[22]=calcMtCrc(bytes)
	1506	else
	1507	-- ensure tag.SSC set to 'ff' on credential-token (SAM)
	1508	bytes[9]='ff'
	1509	-- if a Master-Token was converted to a Credential-Token
	1510	-- lets unset the Time-Area to 00 00 (will contain Stamp-Data on MT)
	1511	bytes[21]='00'
	1512	bytes[22]='00'
	1513	end
	1514
	1515	tag=bytesToTag(bytes, tag)
	1516	end
	1517	end
	1518
	1519	---
	1520	-- calculates header-byte (addr 0x07)
	1521	function calcHeaderRaw(wrp, wrc, rd)
	1522	local res
	1523	wrp=("%02x"):format(tonumber(wrp, 10))
	1524	rd=tonumber(rd, 16)
	1525	res=("%02x"):format(tonumber(wrp, 16)+tonumber(wrc.."0", 16)+((rd>0) and tonumber("8"..(rd-1), 16) or 0))
	1526	return res
	1527	end
	1528
	1529	---
	1530	-- determine TagType (bits 0..6 of DCFlow)
	1531	function getTokenType(DCFl)
	1532	--[[
	1533	0x00–0x2f IAM
	1534	0x30–0x6f SAM
	1535	0x70–0x7f GAM
	1536	]]--
	1537	local tt = tonumber(bbit("0x"..DCFl,0,7),10)
	1538	if (tt >= 0 and tt <= 47) then tt = "IAM"
	1539	elseif (tt == 49) then tt = "SAM63"
	1540	elseif (tt == 48) then tt = "SAM64"
	1541	elseif (tt >= 50 and tt <= 111) then tt = "SAM"
	1542	elseif (tt >= 112 and tt <= 127) then tt = "GAM"
	1543	else tt = "???" end
	1544	return tt
	1545	end
	1546
	1547	---
	1548	-- clear beackup-area of a virtual tag
	1549	function clearBackupArea(tag)
	1550	for i=1, #tag.Bck do
	1551	tag.Bck[i]='00'
	1552	end
	1553	return tag
	1554	end
	1555
	1556	--- Segment related --
	1557	---
	1558	-- get segmemnt-data from byte-table
	1559	function getSegmentData(bytes, start, index)
	1560	local segment={
	1561	['index'] = '00',
	1562	['flag'] = 'c',
	1563	['valid'] = 0,
	1564	['last'] = 0,
	1565	['len'] = 13,
	1566	['raw'] = {'00', '00', '00', '00'},
	1567	['WRP'] = 4,
	1568	['WRC'] = 0,
	1569	['RD'] = 0,
	1570	['crc'] = '00',
	1571	['data'] = {},
	1572	['kgh'] = false
	1573	}
	1574	if (bytes[start]) then
	1575	local i
	1576	-- #index
	1577	segment.index = index
	1578	-- flag = high nibble of byte 1
	1579	segment.flag = string.sub(bytes[start+1],0,1)
	1580	-- valid = bit 6 of byte 1
	1581	segment.valid = bbit("0x"..bytes[start+1],6,1)
	1582	-- last = bit 7 of byte 1
	1583	segment.last = bbit("0x"..bytes[start+1],7,1)
	1584	-- len = (byte 0)+(bit0-3 of byte 1)
	1585	segment.len = tonumber(bbit("0x"..bytes[start+1],0,4)..bytes[start],16)
	1586	-- raw segment header
	1587	segment.raw = {bytes[start], bytes[start+1], bytes[start+2], bytes[start+3]}
	1588	-- wrp (write proteted) = byte 2
	1589	segment.WRP = tonumber(bytes[start+2],16)
	1590	-- wrc (write control) - bit 4-6 of byte 3
	1591	segment.WRC = tonumber(bbit("0x"..bytes[start+3],4,3),16)
	1592	-- rd (read disabled) - bit 7 of byte 3
	1593	segment.RD = tonumber(bbit("0x"..bytes[start+3],7,1),16)
	1594	-- crc byte 4
	1595	segment.crc = bytes[start+4]
	1596	-- segment-data starts at segment.len - segment.header - segment.crc
	1597	for i=0, (segment.len-5) do
	1598	segment.data[i]=bytes[start+5+i]
	1599	end
	1600	return segment
	1601	else return false;
	1602	end
	1603	end
	1604
	1605	---
	1606	-- get index, start-aadr, length and content
	1607	function getSegmentStats(bytes)
	1608	local sStats = {}
	1609	local sValid, sLast, sLen, sStart, x
	1610	sStart=23
	1611	x=0
	1612	repeat
	1613	local s={}
	1614	-- valid = bit 6 of byte 1
	1615	sValid = bbit("0x"..bytes[sStart+1],6,1)
	1616	-- last = bit 7 of byte 1
	1617	sLast = bbit("0x"..bytes[sStart+1],7,1)
	1618	-- len = (byte 0)+(bit0-3 of byte 1)
	1619	sLen = tonumber(bbit("0x"..bytes[sStart+1],0,4)..bytes[sStart],16)
	1620	--print("index: "..("%02d"):format(x).." Len: "..sLen.." start:"..sStart.." end: "..(sStart+sLen-1))
	1621	s['index']=x
	1622	s['start']=sStart
	1623	s['end']=sStart+sLen-1
	1624	s['len']=sLen
	1625	if ( (sStart+sLen-1)>sStart ) then
	1626	table.insert(sStats, s)
	1627	end
	1628	sStart=sStart+sLen
	1629	x=x+1
	1630	until (sLast==1 or sValid==0 or x==126)
	1631	if (#sStats>0 ) then return sStats
	1632	else return false; end
	1633	end
	1634
	1635	---
	1636	-- regenerate segment-header (after edit)
	1637	function regenSegmentHeader(segment)
	1638	local seg=segment
	1639	local raw = segment.raw
	1640	local i
	1641	-- len bit0..7 \| len=12bit=low nibble of byte1..byte0
	1642	raw[1]=("%02x"):format(bbit("0x"..("%03x"):format(seg.len),0,8))
	1643	-- high nibble of len bit6=valid , bit7=last of byte 1 \| ?what are bit 5+6 for? maybe kgh?
	1644	raw[2]=("%02x"):format(bbit("0x"..("%03x"):format(seg.len),8,4)+bbit("0x"..("%02x"):format((seg.valid64)+(seg.last128)),0,8))
	1645	-- WRP
	1646	raw[3]=("%02x"):format(bbit("0x"..("%02x"):format(seg.WRP),0,8))
	1647	-- WRC + RD
	1648	raw[4]=("%02x"):format(tonumber((seg.WRC16)+(seg.RD128),10))
	1649	-- flag
	1650	seg.flag=string.sub(raw[2],0,1)
	1651	--print(raw[1].." "..raw[2].." "..raw[3].." "..raw[4])
	1652	if(#seg.data>(seg.len-5)) then
	1653	print("current payload: ".. #seg.data .." - desired payload: ".. seg.len-5)
	1654	print(acyellow.."Data-Length has being reduced:"..acgreen.." auto-removing "..acyellow.. #seg.data-(seg.len-5) ..acgreen .." bytes from Payload!"..acoff);
	1655	for i=(seg.len-5), #seg.data-1 do
	1656	table.remove(seg.data)
	1657	end
	1658	elseif (#seg.data<(seg.len-5)) then
	1659	print("current payload: ".. #seg.data .." - desired payload: ".. seg.len-5)
	1660	print(acyellow.."Data-Length has being extended:"..acgreen.." auto-adding "..acyellow..(seg.len-5)-#seg.data ..acgreen .." bytes to Payload!"..acoff);
	1661	for i=#seg.data, (seg.len-5-1) do
	1662	table.insert(seg.data, '00')
	1663	end
	1664	end
	1665	return seg
	1666	end
	1667
	1668	---
	1669	-- edit segment helper
	1670	function editSegment(tag, index)
	1671	local k,v
	1672	local edit_possible="valid len RD WRP WRC Stamp Payload"
	1673	if (istable(tag.SEG[index])) then
	1674	for k,v in pairs(tag.SEG[index]) do
	1675	if(string.find(edit_possible,k)) then
	1676	tag.SEG[index][k]=tonumber(input(accyan..k..acoff..": ", v),10)
	1677	end
	1678	end
	1679	else print("Segment with Index: "..("%02d"):format(index).." not found in Tag")
	1680	return false
	1681	end
	1682	regenSegmentHeader(tag.SEG[index])
	1683	print("\n"..dumpSegment(tag, index).."\n")
	1684	return tag
	1685	end
	1686
	1687	---
	1688	-- edit Segment Data
	1689	function editSegmentData(data)
	1690	local lc=check4LegicCash(data)
	1691	io.write("\n")
	1692	if (istable(data)) then
	1693	for i=0, #data-1 do
	1694	data[i]=input(accyan.."Data"..i..acoff..": ", data[i])
	1695	end
	1696	if (lc) then data=fixLegicCash(data) end
	1697	return data
	1698	else
	1699	print("no Segment-Data found")
	1700	end
	1701	end
	1702
	1703	---
	1704	-- list available segmets in virtual tag
	1705	function segmentList(tag)
	1706	local i
	1707	local res = ""
	1708	if (istable(tag.SEG[0])) then
	1709	for i=0, #tag.SEG do
	1710	res = res .. tag.SEG[i].index .. " "
	1711	end
	1712	return res
	1713	else print("no Segments found in Tag")
	1714	return false
	1715	end
	1716	end
	1717
	1718	---
	1719	-- helper to selecting a segment
	1720	function selectSegment(tag)
	1721	local sel
	1722	if (istable(tag.SEG[0])) then
	1723	print("availabe Segments:\n"..segmentList(tag))
	1724	sel=input("select Segment: ", '00')
	1725	sel=tonumber(sel,10)
	1726	if (sel) then return sel
	1727	else return '0' end
	1728	else
	1729	print("\nno Segments found")
	1730	return false
	1731	end
	1732	end
	1733
	1734	---
	1735	-- add segment
	1736	function addSegment(tag)
	1737	local i
	1738	local segment={
	1739	['index'] = '00',
	1740	['flag'] = 'c',
	1741	['valid'] = 1,
	1742	['last'] = 1,
	1743	['len'] = 13,
	1744	['raw'] = {'0d', '40', '04', '00'},
	1745	['WRP'] = 4,
	1746	['WRC'] = 0,
	1747	['RD'] = 0,
	1748	['crc'] = '00',
	1749	['data'] = {},
	1750	['kgh'] = false
	1751	}
	1752	if (istable(tag.SEG[0])) then
	1753	tag.SEG[#tag.SEG].last=0
	1754	table.insert(tag.SEG, segment)
	1755	for i=0, 8 do
	1756	tag.SEG[#tag.SEG].data[i]=("%02x"):format(i)
	1757	end
	1758	tag.SEG[#tag.SEG].index=("%02d"):format(#tag.SEG)
	1759	return tag
	1760	else
	1761	print("no Segment-Table found")
	1762	end
	1763	end
	1764
	1765	---
	1766	-- get only the stamp-bytes of a segment
	1767	function getSegmentStamp(seg, bytes)
	1768	local stamp=""
	1769	local stamp_len=7
	1770	--- the 'real' stamp on MIM is not really easy to tell for me since the 'data-block' covers stamp0..stampn+data0..datan
	1771	-- there a no stamps longer than 7 bytes & they are write-protected by default , and I have not seen user-credntials
	1772	-- with stamps smaller 3 bytes (except: Master-Token)
	1773	-- WRP -> Read/Write Protection
	1774	-- WRC -> Read/Write Condition
	1775	-- RD depends on WRC - if WRC > 0 and RD=1: only reader with matching #WRC of Stamp-bytes in thier Database have Read-Access to the Tag
	1776	if (seg.WRP<7) then stamp_len=(seg.WRP) end
	1777	for i=1, (stamp_len) do
	1778	stamp=stamp..seg.data[i-1]
	1779	end
	1780	if (bytes) then
	1781	stamp=str2bytes(stamp)
	1782	return stamp
	1783	else return stamp end
	1784	end
	1785
	1786	---
	1787	-- edit stamp of a segment
	1788	function editStamp(new_stamp, uid, data)
	1789	local stamp=str2bytes(new_stamp)
	1790	for i=0, #stamp-1 do
	1791	data[i]=stamp[i+1]
	1792	end
	1793	-- now fill in stamp
	1794	for i=0, (string.len(new_stamp)/2)-1 do
	1795	data[i]=stamp[i+1]
	1796	end
	1797	return fix3rdPartyCash1(uid, data)
	1798	end
	1799
	1800	---
	1801	-- autoselect special/known segments
	1802	function autoSelectSegment(tag, s)
	1803	local uid=tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2
	1804	local x=#tag.SEG+1
	1805	local res = false
	1806	io.write("autoSelect ")
	1807	--- search for desired segment-type
	1808	-- 3rd Party Segment
	1809	if (s=="3rdparty") then
	1810	repeat
	1811	io.write(". ")
	1812	x=x-1
	1813	res=check43rdPartyCash1(uid, tag.SEG[x].data)
	1814	until ( res or x==0 )
	1815	end
	1816	-- Legic-Cash Segment
	1817	if (s=="legiccash") then
	1818	repeat
	1819	io.write(". ")
	1820	x=x-1
	1821	res=check4LegicCash(tag.SEG[x].data)
	1822	until ( res or x==0 )
	1823	end
	1824	---
	1825	-- segment found
	1826	if (res) then
	1827	io.write("\nautoselected Index: "..string.format("%02d", x).."\n")
	1828	return x
	1829	end
	1830	---
	1831	-- nothing found
	1832	io.write(acyellow.."no Segment found\n"..acoff)
	1833	return -1
	1834	end
	1835
	1836	---
	1837	-- delete segment (except segment 00)
	1838	function delSegment(tag, index)
	1839	if (istable(tag.SEG[0])) then
	1840	local i
	1841	if (type(index)=="string") then index=tonumber(index,10) end
	1842	if (index > 0) then
	1843	table.remove(tag.SEG, index)
	1844	for i=0, #tag.SEG do
	1845	tag.SEG[i].index=("%02d"):format(i)
	1846	end
	1847	end
	1848	if(istable(tag.SEG[#tag.SEG])) then tag.SEG[#tag.SEG].last=1 end
	1849	return tag
	1850	end
	1851	end
	1852
	1853	---
	1854	-- edit uid 3rd party cash
	1855	function edit3rdUid(mapid, uid, data)
	1856	mapid=("%06x"):format(tonumber(mapid, 10))
	1857	data[46]=string.sub(mapid, 1 ,2)
	1858	data[47]=string.sub(mapid, 3 ,4)
	1859	data[48]=string.sub(mapid, 5 ,6)
	1860	return fix3rdPartyCash1(uid, data)
	1861	end
	1862
	1863	---
	1864	-- edit balance 3rd party cash
	1865	function edit3rdCash(new_cash, uid, data)
	1866	new_cash=("%04x"):format(new_cash)
	1867	data[32]=string.sub(new_cash, 0,2)
	1868	data[33]=string.sub(new_cash, 3,4)
	1869	data[34]=("%02x"):format(utils.Crc8Legic(uid..new_cash))
	1870	data[35]=string.sub(new_cash, 0,2)
	1871	data[36]=string.sub(new_cash, 3,4)
	1872	data[37]=("%02x"):format(utils.Crc8Legic(uid..new_cash))
	1873	data[39]=string.sub(new_cash, 0,2)
	1874	data[40]=string.sub(new_cash, 3,4)
	1875	data[41]='00'
	1876	data[42]='00'
	1877	data[43]='00'
	1878	data[44]='00'
	1879	return fix3rdPartyCash1(uid, data)
	1880	end
	1881
	1882	---
	1883	-- edit 3rd-party cash
	1884	function edit3rdPartyCash1(tag, x)
	1885	local uid=tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2
	1886	if (confirm("\nedit Balance?")) then
	1887	local new_cash=input("enter new Balance≤\nwithout comma and without currency-sign! (0-65535)", "100")
	1888	tag.SEG[x].data=edit3rdCash(new_cash, uid, tag.SEG[x].data)
	1889	end
	1890	-- change User-ID (used for online-account-mapping)
	1891	if (confirm("\nedit UserID-Mapping?")) then
	1892	local new_mapid=input("enter new UserID (6-digit value)", "012345")
	1893	tag.SEG[x].data=edit3rdUid(new_mapid, uid, tag.SEG[x].data)
	1894	end
	1895	if (confirm("\nedit Stamp?")) then
	1896	local new_stamp=input("enter new Stamp", getSegmentStamp(tag.SEG[x]))
	1897	tag.SEG[x].data=editStamp(new_stamp, uid, tag.SEG[x].data)
	1898	new_stamp=getSegmentStamp(tag.SEG[x], 'true')
	1899	print("stamp_bytes: "..#new_stamp)
	1900	-- replace stamp in 'block 1' also
	1901	io.write("editing stamp in Block 1 also ")
	1902	for i=20, (20+#new_stamp-1) do
	1903	tag.SEG[x].data[i]=new_stamp[i-19]
	1904	io.write(".");
	1905	end
	1906	print(" done")
	1907	-- fix known checksums
	1908	tag.SEG[x].data=fix3rdPartyCash1(uid, tag.SEG[x].data)
	1909	end
	1910	return tag
	1911	end
	1912
	1913	---
	1914	-- edit Legic Cash
	1915	function editLegicCash(data)
	1916	local limit, curr, balance, rid, tcv
	1917	-- currency of balance & limit
	1918	curr=currency[data[8]..data[9]]
	1919	-- maximum balance
	1920	limit=string.format("%4.2f", tonumber(data[10]..data[11]..data[12], 16)/100)
	1921	-- current balance
	1922	balance=string.format("%4.2f", tonumber(data[15]..data[16]..data[17], 16)/100)
	1923	-- reader-id who wrote last transaction
	1924	rid=tonumber(data[18]..data[19]..data[20], 16)
	1925	-- transaction counter value
	1926	tcv=tonumber(data[29], 16)
	1927
	1928	-- edit currency
	1929	if (confirm(accyan.."change Currency?"..acoff)) then
	1930	for k, v in pairs(currency) do io.write(k .. " = " .. v .. "\n") end
	1931	curr=input(accyan.."enter the 4-digit Hex for the new Currency:"..acoff, data[8]..data[9])
	1932	data[8]=string.sub(curr, 1, 2)
	1933	data[9]=string.sub(curr, 3, 4)
	1934	end
	1935
	1936	-- edit limit
	1937	if (confirm(accyan.."change Limit?"..acoff)) then
	1938	limit=string.format("%06x", input(accyan.."enter the Decimal for the new Limit:"..acoff, limit))
	1939	data[10]=string.sub(limit, 1, 2)
	1940	data[11]=string.sub(limit, 3, 4)
	1941	data[12]=string.sub(limit, 5, 6)
	1942	end
	1943
	1944	-- edit balance
	1945	if (confirm(accyan.."change Balance?"..acoff)) then
	1946	balance=string.format("%06x", input(accyan.."enter the Decimal for the new Balance:"..acoff, balance))
	1947	print("Balance: "..balance)
	1948	data[15]=string.sub(balance, 1, 2)
	1949	data[16]=string.sub(balance, 3, 4)
	1950	data[17]=string.sub(balance, 5, 6)
	1951	end
	1952
	1953	-- edit transaction-counter
	1954	if (confirm(accyan.."change Transaction-Counter?"..acoff)) then
	1955	tcv=string.format("%02x", input(accyan.."enter the 4-digit Hex for the new Currency:"..acoff, data[29]))
	1956	data[29]=tcv
	1957	end
	1958
	1959	-- edit reader.id
	1960	if (confirm(accyan.."change Last-Reader-ID?"..acoff)) then
	1961	rid=string.format("%06x", input(accyan.."enter the Decimal for the new Balance:"..acoff, rid))
	1962	print("Balance: "..balance)
	1963	data[18]=string.sub(rid, 1, 2)
	1964	data[19]=string.sub(rid, 3, 4)
	1965	data[20]=string.sub(rid, 5, 6)
	1966	end
	1967
	1968	return fixLegicCash(data)
	1969	end
	1970
	1971	---
	1972	-- chack for signature of a 'Legic-Cash-Segment'
	1973	function check4LegicCash(data)
	1974	if(#data==32) then
	1975	local stamp_len=(#data-25)
	1976	local stamp=""
	1977	for i=0, stamp_len-1 do
	1978	stamp=stamp..data[i].." "
	1979	end
	1980	if (data[7]=="01") then
	1981	if (("%04x"):format(utils.Crc16(dumpTable(data, "", 0, 12))) == data[13]..data[14]) then
	1982	if (("%04x"):format(utils.Crc16(dumpTable(data, "", 15, 20))) == data[21]..data[22]) then
	1983	if (("%04x"):format(utils.Crc16(dumpTable(data, "", 23, 29))) == data[30]..data[31]) then
	1984	io.write(accyan.."Legic-Cash Segment detected "..acoff)
	1985	return true
	1986	end
	1987	end
	1988	end
	1989	end
	1990	end
	1991	return false
	1992	end
	1993
	1994	---
	1995	-- chack for signature of a '3rd Party Cash-Segment' - not all bytes know until yet !!
	1996	function check43rdPartyCash1(uid, data)
	1997	if(#data==95) then
	1998	-- too explicit checking will avoid fixing ;-)
	1999	if (string.find(compareCrc(utils.Crc8Legic(uid..dumpTable(data, "", 19, 30)), data[31]),"valid")) then
	2000	--if (compareCrc(utils.Crc8Legic(uid..data[32]..data[33]), data[34])=="valid") then
	2001	--if (compareCrc(utils.Crc8Legic(uid..data[35]..data[36]), data[37])=="valid") then
	2002	--if (compareCrc(utils.Crc8Legic(uid..dumpTable(data, "", 56, 61)), data[62])=="valid") then
	2003	--if (compareCrc(utils.Crc8Legic(uid..dumpTable(data, "", 74, 88)), data[89])=="valid") then
	2004	io.write(accyan.."3rd Party Cash-Segment detected "..acoff)
	2005	return true
	2006	--end
	2007	--end
	2008	--end
	2009	--end
	2010	end
	2011	end
	2012	return false
	2013	end
	2014
	2015	--- CRC related ---
	2016	---
	2017	-- build segmentCrc credentials
	2018	function segmentCrcCredentials(tag, segid)
	2019	if (istable(tag.SEG[0])) then
	2020	local cred = tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2
	2021	cred = cred ..tag.SEG[segid].raw[1]..tag.SEG[segid].raw[2]..tag.SEG[segid].raw[3]..tag.SEG[segid].raw[4]
	2022	return cred
	2023	else return print(acyellow.."Master-Token / unsegmented Tag!"..acoff) end
	2024	end
	2025
	2026	---
	2027	-- build kghCrc credentials
	2028	function kghCrcCredentials(tag, segid)
	2029	if (istable(tag) and istable(tag.SEG[0])) then
	2030	local x='00'
	2031	if (type(segid)=="string") then segid=tonumber(segid,10) end
	2032	if (segid>0) then x='93' end
	2033	local cred = tag.MCD..tag.MSN0..tag.MSN1..tag.MSN2..("%02x"):format(tag.SEG[segid].WRP)
	2034	cred = cred..("%02x"):format(tag.SEG[segid].WRC)..("%02x"):format(tag.SEG[segid].RD)..x
	2035	for i=0, #tag.SEG[segid].data-2 do
	2036	cred = cred..tag.SEG[segid].data[i]
	2037	end
	2038	return cred
	2039	end
	2040	end
	2041
	2042	---
	2043	-- compare two bytes
	2044	function compareCrc(calc, guess)
	2045	calc=("%02x"):format(calc)
	2046	if (calc==guess) then return acgreen.."valid"..acoff
	2047	else return acred.."error "..acoff..calc.."!="..guess end
	2048	end
	2049
	2050	---
	2051	-- compare 4 bytes
	2052	function compareCrc16(calc, guess)
	2053	calc=("%04x"):format(calc)
	2054	if (calc==guess) then return acgreen.."valid"..acoff
	2055	else return acred.."error "..acoff..calc.."!="..guess end
	2056	end
	2057
	2058	---
	2059	-- repair / fix crc's of a 'Legic-Cash-Segment'
	2060	function fixLegicCash(data)
	2061	if(#data==32 and data[7]=="01") then
	2062	local crc1, crc2, crc3
	2063	-- set shadow-balance equal to balance
	2064	data[23]=data[15]
	2065	data[24]=data[16]
	2066	data[25]=data[17]
	2067	-- set shadow-last-reader to last-reader
	2068	data[26]=data[18]
	2069	data[27]=data[19]
	2070	data[28]=data[20]
	2071	-- calculate all crc's
	2072	crc1=("%04x"):format(utils.Crc16(dumpTable(data, "", 0, 12)))
	2073	crc2=("%04x"):format(utils.Crc16(dumpTable(data, "", 15, 20)))
	2074	crc3=("%04x"):format(utils.Crc16(dumpTable(data, "", 23, 29)))
	2075	-- set crc's
	2076	data[13]=string.sub(crc1, 1, 2)
	2077	data[14]=string.sub(crc1, 3, 4)
	2078	data[21]=string.sub(crc2, 1, 2)
	2079	data[22]=string.sub(crc2, 3, 4)
	2080	data[30]=string.sub(crc3, 1, 2)
	2081	data[31]=string.sub(crc3, 3, 4)
	2082	return data
	2083	end
	2084	end
	2085
	2086	---
	2087	-- repair / fix (yet known) crc's of a '3rd Party Cash-Segment' - not all bytes know until yet !!
	2088	function fix3rdPartyCash1(uid, data)
	2089	if(#data==95) then
	2090	-- checksum 1
	2091	data[31]=("%02x"):format(utils.Crc8Legic(uid..dumpTable(data, "", 19, 30)))
	2092	-- checksum 2
	2093	data[34]=("%02x"):format(utils.Crc8Legic(uid..data[32]..data[33]))
	2094	-- checksum 3
	2095	data[37]=("%02x"):format(utils.Crc8Legic(uid..data[35]..data[36]))
	2096	-- checksum 4
	2097	data[55]=("%02x"):format(utils.Crc8Legic(uid..dumpTable(data, "", 46, 54)))
	2098	-- checksum 5
	2099	data[62]=("%02x"):format(utils.Crc8Legic(uid..dumpTable(data, "", 56, 61)))
	2100	-- checksum 6
	2101	data[73]=("%02x"):format(utils.Crc8Legic(uid..dumpTable(data, "", 63, 72)))
	2102	-- checksum 7
	2103	data[89]=("%02x"):format(utils.Crc8Legic(uid..dumpTable(data, "", 74, 88)))
	2104	return data
	2105	end
	2106	end
	2107
	2108	---
	2109	-- calculate Master-Token crc
	2110	function calcMtCrc(bytes)
	2111	--print(#bytes)
	2112	local cmd=bytes[1]..bytes[2]..bytes[3]..bytes[4]..bytes[7]..bytes[6]..bytes[8]
	2113	local len=(tonumber(0xfc ,10)-("%d"):format('0x'..bytes[7]))
	2114	for i=1, len do
	2115	cmd=cmd..bytes[8+i]
	2116	end
	2117	local res=("%02x"):format(utils.Crc8Legic(cmd))
	2118	return res
	2119	end
	2120
	2121	---
	2122	-- calculate segmentCRC for a given segment
	2123	function calcSegmentCrc(tag, segid)
	2124	if (istable(tag.SEG[0])) then
	2125	-- check if a 'Kaber Group Header' exists
	2126	local data=segmentCrcCredentials(tag, segid)
	2127	return ("%02x"):format(utils.Crc8Legic(data))
	2128	end
	2129	end
	2130
	2131	---
	2132	-- calcuate kghCRC for a given segment
	2133	function calcKghCrc(tag, segid)
	2134	if (istable(tag.SEG[0])) then
	2135	-- check if a 'Kaber Group Header' exists
	2136	local i
	2137	local data=kghCrcCredentials(tag, segid)
	2138	return ("%02x"):format(utils.Crc8Legic(data))
	2139	end
	2140	end
	2141
	2142	---
	2143	-- check all segmnet-crc
	2144	function checkAllSegCrc(tag)
	2145	if (istable(tag.SEG[0])) then
	2146	for i=0, #tag.SEG do
	2147	crc=calcSegmentCrc(tag, i)
	2148	tag.SEG[i].crc=crc
	2149	end
	2150	else return print(acyellow.."Master-Token / unsegmented Tag"..acoff) end
	2151	end
	2152
	2153	---
	2154	-- check all segmnet-crc
	2155	function checkAllKghCrc(tag)
	2156	if (istable(tag.SEG[0])) then
	2157	for i=0, #tag.SEG do
	2158	crc=calcKghCrc(tag, i)
	2159	if (tag.SEG[i].kgh) then
	2160	tag.SEG[i].data[#tag.SEG[i].data-1]=crc
	2161	end
	2162	end
	2163	end
	2164	end
	2165
	2166	---
	2167	-- validate segmentCRC for a given segment
	2168	function checkSegmentCrc(tag, segid)
	2169	local data=segmentCrcCredentials(tag, segid)
	2170	if (("%02x"):format(utils.Crc8Legic(data))==tag.SEG[segid].crc) then
	2171	return true
	2172	end
	2173	return false
	2174	end
	2175
	2176	---
	2177	-- validate kghCRC to segment in tag-table
	2178	function checkKghCrc(tag, segid)
	2179	if (type(tag.SEG[segid])=='table') then
	2180	if (tag.data[3]=="11" and tag.raw=="9f" and tag.SSC=="ff") then
	2181	local data=kghCrcCredentials(tag, segid)
	2182	if (("%02x"):format(utils.Crc8Legic(data))==tag.SEG[segid].data[tag.SEG[segid].len-5-1]) then return true; end
	2183	else return false; end
	2184	else oops(acred.."'Kaba Group header' detected but no Segment-Data found"..ansocolors.reset) end
	2185	end
	2186
	2187	---
	2188	-- helptext for modify-mode
	2189	function modifyHelp()
	2190	local t=[[
	2191
	2192	Data I/O Segment Manipulation Token-Data
	2193	----------------- -------------------- ---------------------
	2194	rt => read Tag as => add Segment mt => make Token
	2195	wt => write Tag es => edit Segment Header et => edit Token data
	2196	ed => edit Segment Data tk => toggle KGH-Flag
	2197	File I/O rs => remove Segment
	2198	----------------- cc => check Segment-CRC
	2199	lf => load File ck => check KGH
	2200	sf => save File ds => dump Segments
	2201	xf => xor to File
	2202
	2203
	2204	Virtual Tags tagMap (partial) known Segments
	2205	-------------------------------- --------------------- ---------------------------
	2206	ct => copy mainTag to backupTag mm => make (new) Map dlc => dump Legic-Cash
	2207	tc => copy backupTag to mainTag em => edit Map submenu elc => edit Legic-Cash
	2208	tt => switch mainTag & backupTag lm => load map from file d3p => dump 3rd-Party-Cash
	2209	di => dump mainTag sm => save map to file e3p => edit 3rd-Party-Cash
	2210	do => dump backupTag
	2211
	2212	h => this help q => quit
	2213	]]
	2214	return t
	2215	end
	2216
	2217	---
	2218	-- modify Tag (interactive)
	2219	function modifyMode()
	2220	local i, backupTAG, outTAG, inTAG, outfile, infile, sel, segment, bytes, outbytes, tagMap
	2221
	2222	actions = {
	2223	---
	2224	-- helptext
	2225	["h"] = function(x)
	2226	print(" Version: "..version);
	2227	print(modifyHelp().."\n".."tags im Memory: "..(istable(inTAG) and ((currentTag=='inTAG') and acgreen.."mainTAG"..acoff or "mainTAG") or "").." "..(istable(backupTAG) and ((currentTag=='backupTAG') and acgreen.."backupTAG"..acoff or "backupTAG") or ""))
	2228	end,
	2229	---
	2230	-- read real Tag with PM3 into virtual 'mainTAG'
	2231	["rt"] = function(x)
	2232	inTAG=readFromPM3();
	2233	--actions.di()
	2234	end,
	2235	---
	2236	-- write content of virtual 'mainTAG' to real Tag with PM3
	2237	["wt"] = function(x)
	2238	writeToTag(inTAG)
	2239	end,
	2240	---
	2241	-- copy mainTAG to backupTAG
	2242	["ct"] = function(x)
	2243	print(accyan.."copy mainTAG to backupTAG"..acoff)
	2244	backupTAG=deepCopy(inTAG)
	2245	end,
	2246	---
	2247	-- copy backupTAG to mainTAG
	2248	["tc"] = function(x)
	2249	print(accyan.."copy backupTAG to mainTAG"..acoff)
	2250	inTAG=deepCopy(backupTAG)
	2251	end,
	2252	---
	2253	-- toggle between mainTAG and backupTAG
	2254	["tt"] = function(x)
	2255	-- copy main to temp
	2256	outTAG=deepCopy(inTAG)
	2257	-- copy backup to main
	2258	inTAG=deepCopy(backupTAG)
	2259	print(accyan.."toggle to "..accyan..((currentTag=='inTAG') and "backupTAG" or "mainTAG")..acoff)
	2260	if(currentTag=="inTAG") then currentTag='backupTAG'
	2261	else currentTag='inTAG' end
	2262	-- copy temp (main) to backup
	2263	backupTAG=deepCopy(outTAG)
	2264	end,
	2265	---
	2266	-- load file into mainTAG
	2267	["lf"] = function(x)
	2268
	2269	if (type(x)=='string' and file_check(x)) then filename=x
	2270	else filename=input("enter filename: ", "legic.temp") end
	2271	inTAG=readFile(filename)
	2272	-- check for existing tagMap
	2273	if (file_check(filename..".map")) then
	2274	if(confirm(accyan.."Mapping-File for "..acoff..filename..accyan.." found - load it also?"..acoff)) then
	2275	tagMap=loadTagMap(filename..".map")
	2276	end
	2277	end
	2278	end,
	2279	---
	2280	-- save values of mainTAG to a file (xored with MCC of mainTAG)
	2281	["sf"] = function(x)
	2282	if(istable(inTAG)) then
	2283	outfile=input("enter filename:", "legic.temp")
	2284	bytes=tagToBytes(inTAG)
	2285	--bytes=xorBytes(bytes, inTAG.MCC)
	2286	if (bytes) then
	2287	writeFile(bytes, outfile)
	2288	end
	2289	end
	2290	end,
	2291	---
	2292	-- save values of mainTAG to a file (xored with 'specific' MCC)
	2293	["xf"] = function(x)
	2294	if(istable(inTAG)) then
	2295	outfile=input("enter filename:", "legic.temp")
	2296	crc=input("enter new crc: ('00' for a plain dump)", inTAG.MCC)
	2297	print("obfuscate witth: "..crc)
	2298	bytes=tagToBytes(inTAG)
	2299	bytes[5]=crc
	2300	if (bytes) then
	2301	writeFile(bytes, outfile)
	2302	end
	2303	end
	2304	end,
	2305	---
	2306	-- dump mainTAG (and all Segments)
	2307	["di"] = function(x)
	2308	if (istable(inTAG)) then
	2309	local uid=inTAG.MCD..inTAG.MSN0..inTAG.MSN1..inTAG.MSN2
	2310	if(istable(inTAG.SEG[0])) then
	2311	for i=0, #inTAG.SEG do
	2312	if(check43rdPartyCash1(uid, inTAG.SEG[i].data)) then
	2313	io.write(accyan.."in Segment index: "..inTAG.SEG[i].index ..acoff.. "\n")
	2314	elseif(check4LegicCash(inTAG.SEG[i].data)) then
	2315	io.write(accyan.."in Segment index: "..inTAG.SEG[i].index..acoff.."\n")
	2316	lc=true;
	2317	lci=inTAG.SEG[i].index;
	2318	end
	2319	end
	2320	end
	2321	print("\n"..dumpTag(inTAG).."\n")
	2322	if (lc) then actions["dlc"](lci) end
	2323	lc=false
	2324	end
	2325	end,
	2326	---
	2327	-- dump backupTAG (and all Segments)
	2328	["do"] = function(x) if (istable(backupTAG)) then print("\n"..dumpTag(backupTAG).."\n") end end,
	2329	---
	2330	-- create a empty tagMap
	2331	["mm"] = function(x)
	2332	-- clear existing tagMap and init
	2333	if (istable(inTAG)) then
	2334	tagMap=makeTagMap()
	2335	end
	2336	end,
	2337	---
	2338	-- edit a tagMap
	2339	["em"] = function(x)
	2340	if (istable(inTAG)==false) then
	2341	if (confirm("no mainTAG in memory!\nread from PM3?")) then
	2342	actions['rt']()
	2343	elseif (confirm("load from File?")) then
	2344	actions['lf']()
	2345	else return
	2346	end
	2347	end
	2348	if (istable(tagMap)==false) then actions['mm']() end
	2349	-- edit
	2350	tagMap=editTagMap(inTAG, tagMap)
	2351	end,
	2352	---
	2353	-- save a tagMap
	2354	["sm"] = function(x)
	2355	if (istable(tagMap)) then
	2356	if (istable(tagMap) and #tagMap.mappings>0) then
	2357	print(accyan.."Map contains "..acoff..#tagMap..accyan.." mappings"..acoff)
	2358	saveTagMap(tagMap, input(accyan.."enter filename:"..acoff, "Legic.map"))
	2359	else
	2360	print(acyellow.."no mappings in tagMap!"..acoff)
	2361	end
	2362	end
	2363	end,
	2364	---
	2365	-- load a tagMap
	2366	["lm"] = function(x)
	2367	tagMap=loadTagMap(input(accyan.."enter filename:"..acoff, "Legic.map"))
	2368	end,
	2369	---
	2370	-- dump single segment
	2371	["ds"] = function(x)
	2372	if (type(x)=="string" and string.len(x)>0) then sel=tonumber(x,10)
	2373	else sel=selectSegment(inTAG) end
	2374	if (sel) then print("\n"..(dumpSegment(inTAG, sel) or acred.."no Segments available") ..acoff.."\n") end
	2375	end,
	2376	---
	2377	-- edit segment header
	2378	["es"] = function(x)
	2379	if (type(x)=="string" and string.len(x)>0) then sel=tonumber(x,10)
	2380	else sel=selectSegment(inTAG) end
	2381	if (sel) then
	2382	if(istable(inTAG.SEG[0])) then
	2383	inTAG=editSegment(inTAG, sel)
	2384	inTAG.SEG[sel]=regenSegmentHeader(inTAG.SEG[sel])
	2385	else print(acyellow.."no Segments in Tag"..acoff) end
	2386	end
	2387	end,
	2388	---
	2389	-- add segment
	2390	["as"] = function(x)
	2391	if (istable(inTAG.SEG[0])) then
	2392	inTAG=addSegment(inTAG)
	2393	inTAG.SEG[#inTAG.SEG-1]=regenSegmentHeader(inTAG.SEG[#inTAG.SEG-1])
	2394	inTAG.SEG[#inTAG.SEG]=regenSegmentHeader(inTAG.SEG[#inTAG.SEG])
	2395	else print(accyan.."Master-Token / unsegmented Tag!"..acoff)
	2396	end
	2397	end,
	2398	---
	2399	-- remove segment
	2400	["rs"] = function(x)
	2401	if (istable(inTAG.SEG[0])) then
	2402	if (type(x)=="string" and string.len(x)>0) then sel=tonumber(x,10)
	2403	else sel=selectSegment(inTAG) end
	2404	inTAG=delSegment(inTAG, sel)
	2405	for i=0, #inTAG.SEG do
	2406	inTAG.SEG[i]=regenSegmentHeader(inTAG.SEG[i])
	2407	end
	2408	end
	2409	end,
	2410	---
	2411	-- edit data-portion of single segment
	2412	["ed"] = function(x)
	2413	if (type(x)=="string" and string.len(x)>0) then sel=tonumber(x,10)
	2414	else sel=selectSegment(inTAG) end
	2415	if (istable(inTAG.SEG[sel])) then
	2416	inTAG.SEG[sel].data=editSegmentData(inTAG.SEG[sel].data)
	2417	end
	2418	end,
	2419	---
	2420	-- edit Tag (MCD, MSN, MCC etc.)
	2421	["et"] = function(x)
	2422	if (istable(inTAG)) then
	2423	editTag(inTAG)
	2424	end
	2425	end,
	2426	---
	2427	-- make (dummy) Token
	2428	["mt"] = function(x) inTAG=makeToken(); actions.di() end,
	2429	---
	2430	-- fix segment-crc on single segment
	2431	["ts"] = function(x)
	2432	if (type(x)=="string" and string.len(x)>0) then sel=tonumber(x,10)
	2433	else sel=selectSegment(inTAG) end
	2434	regenSegmentHeader(inTAG.SEG[sel])
	2435	end,
	2436	---
	2437	-- toggle kgh-crc-flag on a single segment
	2438	["tk"] = function(x)
	2439	if (istable(inTAG) and istable(inTAG.SEG[0])) then
	2440	if (type(x)=="string" and string.len(x)>0) then sel=tonumber(x,10)
	2441	else sel=selectSegment(inTAG) end
	2442	if(inTAG.SEG[sel].kgh) then inTAG.SEG[sel].kgh=false
	2443	else inTAG.SEG[sel].kgh=true end
	2444	end
	2445	end,
	2446	---
	2447	-- calculate LegicCrc8
	2448	["k"] = function(x)
	2449	if (type(x)=="string" and string.len(x)>0) then
	2450	print(("%02x"):format(utils.Crc8Legic(x)))
	2451	end
	2452	end,
	2453	---
	2454	-- noop
	2455	["xb"] = function(x)
	2456	end,
	2457	---
	2458	-- print string for LegicCrc8-calculation about single segment
	2459	["xc"] = function(x)
	2460	if (istable(inTAG) and istable(inTAG.SEG[0])) then
	2461	if (type(x)=="string" and string.len(x)>0) then sel=tonumber(x,10)
	2462	else sel=selectSegment(inTAG) end
	2463	print("k "..kghCrcCredentials(inTAG, sel))
	2464	end
	2465	end,
	2466	---
	2467	-- fix legic-cash checksums
	2468	["flc"] = function(x)
	2469	if (type(x)=="string" and string.len(x)>0) then x=tonumber(x,10)
	2470	else x=selectSegment(inTAG) end
	2471	inTAG.SEG[x].data=fixLegicCash(inTAG.SEG[x].data)
	2472	end,
	2473	---
	2474	-- edit legic-cash values fixLegicCash(data)
	2475	["elc"] = function(x)
	2476	x=autoSelectSegment(inTAG, "legiccash")
	2477	inTAG.SEG[x].data=editLegicCash(inTAG.SEG[x].data)
	2478	end,
	2479	---
	2480	-- dump legic-cash human-readable
	2481	["dlc"] = function(x)
	2482	-- if segment index was user defined
	2483	if (type(x)=="string" and string.len(x)>0) then
	2484	x=tonumber(x,10)
	2485	print(string.format("User-Selected Index %02d", x))
	2486	-- or try to find match
	2487	else x=autoSelectSegment(inTAG, "legiccash") end
	2488	-- dump it
	2489	dumpLegicCash(inTAG, x)
	2490	end,
	2491	---
	2492	-- dump 3rd-party-cash-segment
	2493	["d3p"] = function(x)
	2494	local uid=inTAG.MCD..inTAG.MSN0..inTAG.MSN1..inTAG.MSN2
	2495	-- if segment index was user defined
	2496	if (type(x)=="string" and string.len(x)>0) then
	2497	x=tonumber(x,10)
	2498	print(string.format("User-Selected Index %02d", x))
	2499	-- or try to find match
	2500	else x=autoSelectSegment(inTAG, "3rdparty") end
	2501	if (istable(inTAG) and istable(inTAG.SEG[x]) and inTAG.SEG[x].len == 100) then
	2502	uid=inTAG.MCD..inTAG.MSN0..inTAG.MSN1..inTAG.MSN2
	2503	if (check43rdPartyCash1(uid, inTAG.SEG[x].data)) then
	2504	dump3rdPartyCash1(inTAG, x)
	2505	end
	2506	end
	2507	end,
	2508	---
	2509	-- dump 3rd-party-cash-segment (raw blocks and checksums over 'known areas')
	2510	["r3p"] = function(x)
	2511	local uid=inTAG.MCD..inTAG.MSN0..inTAG.MSN1..inTAG.MSN2
	2512	-- if segment index was user defined
	2513	if (type(x)=="string" and string.len(x)>0) then
	2514	x=tonumber(x,10)
	2515	print(string.format("User-Selected Index %02d", x))
	2516	-- or try to find match
	2517	else x=autoSelectSegment(inTAG, "3rdparty") end
	2518	print3rdPartyCash1(inTAG, x)
	2519	end,
	2520	---
	2521	-- edit 3rd-party-cash-segment values (Balance, Mapping-UID, Stamp)
	2522	["e3p"] = function(x)
	2523	local uid=inTAG.MCD..inTAG.MSN0..inTAG.MSN1..inTAG.MSN2
	2524	-- if segment index was user defined
	2525	if (type(x)=="string" and string.len(x)>0) then
	2526	x=tonumber(x,10)
	2527	print(string.format("User-Selected Index %02d", x))
	2528	-- or try to find match
	2529	else x=autoSelectSegment(inTAG, "3rdparty") end
	2530	if (istable(inTAG) and istable(inTAG.SEG[x]) and inTAG.SEG[x].len == 100) then
	2531	inTAG=edit3rdPartyCash1(inTAG, x)
	2532	dump3rdPartyCash1(inTAG, x)
	2533	end
	2534	end,
	2535	---
	2536	-- force fixing 3rd-party-checksums
	2537	["f3p"] = function(x)
	2538	if(type(x)=="string" and string.len(x)>=2) then x=tonumber(x, 10)
	2539	else x=selectSegment(inTAG) end
	2540	if (istable(inTAG.SEG[x])) then
	2541	local uid=inTAG.MCD..inTAG.MSN0..inTAG.MSN1..inTAG.MSN2
	2542	inTAG.SEG[x].data=fix3rdPartyCash1(uid, inTAG.SEG[x].data)
	2543	end
	2544	end,
	2545	---
	2546	-- get stamp from single segment
	2547	["gs"] = function(x)
	2548	if(type(x)=="string" and string.len(x)>=2) then x=tonumber(x, 10)
	2549	else x=selectSegment(inTAG) end
	2550	local stamp=getSegmentStamp(inTAG.SEG[x])
	2551	print("Stamp : "..stamp)
	2552	stamp=str2bytes(stamp)
	2553	print("lenght: "..#stamp)
	2554	end,
	2555	---
	2556	-- calculate crc16
	2557	["c6"] = function(x) local crc16=string.format("%4.04x", utils.Crc16(x))
	2558	print(string.sub(crc16, 0,2).." "..string.sub(crc16, 3,4))
	2559	end,
	2560	---
	2561	-- check & fix segments-crc of all segments
	2562	["cc"] = function(x) if (istable(inTAG)) then checkAllSegCrc(inTAG) end end,
	2563	---
	2564	-- set backup-area-bytes to '00'
	2565	["cb"] = function(x)
	2566	if (istable(inTAG)) then
	2567	print(accyan.."purge BackupArea"..acoff)
	2568	inTAG=clearBackupArea(inTAG)
	2569	end
	2570	end,
	2571	---
	2572	-- check and fix all segments inTAG.SEG[x].kgh toggled 'on'
	2573	["ck"] = function(x) if (istable(inTAG)) then checkAllKghCrc(inTAG) end end,
	2574	---
	2575	-- check and fix all segments inTAG.SEG[x].kgh toggled 'on'
	2576	["tac"] = function(x)
	2577	if (colored_output) then
	2578	colored_output=false
	2579	else
	2580	colored_output=true
	2581	end
	2582	load_colors(colored_output)
	2583	end,
	2584	}
	2585	repeat
	2586	-- defualt message / prompt
	2587	ic=input("Legic command? ('h' for help - 'q' for quit)", "h")
	2588	-- command actions decisions (first match, longer commands before shorter)
	2589	if (type(actions[string.lower(string.sub(ic,0,3))])=='function') then
	2590	actions[string.lower(string.sub(ic,0,3))](string.sub(ic,5))
	2591	elseif (type(actions[string.lower(string.sub(ic,0,2))])=='function') then
	2592	actions[string.lower(string.sub(ic,0,2))](string.sub(ic,4))
	2593	elseif (type(actions[string.lower(string.sub(ic,0,1))])=='function') then
	2594	actions[string.lower(string.sub(ic,0,1))](string.sub(ic,3))
	2595	else actions.h('') end
	2596	until (string.sub(ic,0,1)=="q")
	2597	end
	2598
	2599	---
	2600	-- main function
	2601	function main(args)
	2602	-- set init colors/switch (can be toggled with 'tac' => 'toggle ansicolors')
	2603	load_colors(colored_output)
	2604	if (#args == 0 ) then modifyMode() end
	2605	--- variables
	2606	local inTAG, backupTAG, outTAG, outfile, interactive, crc, ofs, cfs, dfs
	2607	-- just a spacer for better readability
	2608	print()
	2609	--- parse arguments
	2610	for o, a in getopt.getopt(args, 'hrmi:do:c:') do
	2611	-- display help
	2612	if o == "h" then return help(); end
	2613	-- read tag from PM3
	2614	if o == "r" then inTAG=readFromPM3() end
	2615	-- input file
	2616	if o == "i" then inTAG=readFile(a) end
	2617	-- dump virtual-Tag
	2618	if o == "d" then dfs=true end
	2619	-- interacive modifying
	2620	if o == "m" then interactive=true; modifyMode() end
	2621	-- xor (e.g. for clone or plain file)
	2622	if o == "c" then cfs=true; crc=a end
	2623	-- output file
	2624	if o == "o" then outfile=a; ofs=true end
	2625	end
	2626
	2627	-- file conversion (output to file)
	2628	if (ofs) then
	2629	-- dump infile / tag-read
	2630	if (dfs) then
	2631	print("-----------------------------------------")
	2632	print(dumpTag(inTAG))
	2633	end
	2634	bytes=tagToBytes(inTAG)
	2635	if (cfs) then
	2636	-- xor willl be done in function writeFile
	2637	-- with the value of byte[5]
	2638	bytes[5]=crc
	2639	end
	2640	-- write to outfile
	2641	if (bytes) then
	2642	writeFile(bytes, outfile)
	2643	--- read real tag into virtual tag
	2644	-- inTAG=readFromPM3() end
	2645	--- or simply use the bytes that where wriiten
	2646	inTAG=bytesToTag(bytes, inTAG)
	2647	-- show new content
	2648	if (dfs) then
	2649	print("-----------------------------------------")
	2650	print(dumpTag(inTAG))
	2651	end
	2652	end
	2653	end
	2654
	2655	end
	2656
	2657	---
	2658	-- script start
	2659	main(args)