private void Mfid90SendDisconnect() { Mfid90SessionControlVer1 commandKmmBody = new Mfid90SessionControlVer1(); commandKmmBody.SessionControlOpcode = Mfid90SessionControlVer1.ScOpcode.Disconnect; commandKmmBody.SourceDeviceType = Mfid90SessionControlVer1.ScSourceDeviceType.Kfd; commandKmmBody.IsSessionTypeIncluded = false; KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); byte[] toRadio = commandKmmFrame.ToBytesWithPreamble(0x90); byte[] fromRadio = PerformKmmTransfer(toRadio); KmmFrame responseKmmFrame = new KmmFrame(true, fromRadio); KmmBody responseKmmBody = responseKmmFrame.KmmBody; if (responseKmmBody is Mfid90SessionControlVer1) { Mfid90SessionControlVer1 kmm = responseKmmBody as Mfid90SessionControlVer1; if (kmm.SessionControlOpcode != Mfid90SessionControlVer1.ScOpcode.DisconnectAck) { throw new Exception(string.Format("received unexpected session control opcode (0x{0:X2}) {1}", (byte)kmm.SessionControlOpcode, kmm.SessionControlOpcode.ToString())); } } else { throw new Exception("unexpected kmm"); } }
private void SendDisconnect() { SessionControl commandKmmBody = new SessionControl(); commandKmmBody.SessionControlOpcode = SessionControl.ScOpcode.Disconnect; commandKmmBody.SourceDeviceType = SessionControl.ScSourceDeviceType.Kfd; KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); byte[] toRadio = commandKmmFrame.ToBytesWithPreamble(0x00); byte[] fromRadio = PerformKmmTransfer(toRadio); KmmFrame responseKmmFrame = new KmmFrame(true, fromRadio); KmmBody responseKmmBody = responseKmmFrame.KmmBody; if (responseKmmBody is SessionControl) { SessionControl kmm = responseKmmBody as SessionControl; if (kmm.SessionControlOpcode != SessionControl.ScOpcode.DisconnectAck) { throw new Exception(string.Format("received unexpected session control opcode (0x{0:X2}) {1}", (byte)kmm.SessionControlOpcode, kmm.SessionControlOpcode.ToString())); } } else { throw new Exception("unexpected kmm"); } }
private KmmBody TxRxKmm(KmmBody commandKmmBody) { KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); byte[] toRadio = WithPreamble ? commandKmmFrame.ToBytesWithPreamble(Mfid) : commandKmmFrame.ToBytes(); byte[] fromRadio = DeviceProtocol.PerformKmmTransfer(toRadio); KmmFrame responseKmmFrame = new KmmFrame(WithPreamble, fromRadio); return(responseKmmFrame.KmmBody); }
private KmmBody TxRxKmm(KmmBody commandKmmBody) { KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); byte[] toRadio = commandKmmFrame.ToBytes(); Logger.Debug("KFD -> MR KMM FRAME: {0}", BitConverter.ToString(toRadio)); byte[] fromRadio = ThreeWireProtocol.PerformKmmTransfer(toRadio); Logger.Debug("MR -> KFD KMM FRAME: {0}", BitConverter.ToString(fromRadio)); KmmFrame responseKmmFrame = new KmmFrame(fromRadio); return(responseKmmFrame.KmmBody); }
public static int DeleteAuthenticationKey(bool targetSpecificSuId, bool deleteAllKeys, int wacnId, int systemId, int unitId) { Output.DebugLine("DeleteAuthenticationKey() :: targetSpecificSuId: {0}, deleteAllKeys: {1}, wacnId: 0x{2:X}, systemId: 0x{3:X}, unitId: 0x{4:X}", targetSpecificSuId, deleteAllKeys, wacnId, systemId, unitId); SuId commandSuId = new SuId(wacnId, systemId, unitId); Output.DebugLine("command suid - {0}", commandSuId.ToString()); DeleteAuthenticationKeyCommand commandKmmBody = new DeleteAuthenticationKeyCommand(targetSpecificSuId, deleteAllKeys, commandSuId); Output.DebugLine("command kmm body - {0}", commandKmmBody.ToString()); KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); Output.DebugLine("command kmm frame - {0}", commandKmmFrame.ToString()); byte[] toRadio = commandKmmFrame.ToBytes(); byte[] fromRadio; try { fromRadio = Network.QueryRadio(toRadio); } catch (Exception ex) { Output.ErrorLine("unable to connect to radio: {0}", ex.Message); return(-1); } KmmFrame responseKmmFrame = new KmmFrame(fromRadio); Output.DebugLine("response kmm frame - {0}", responseKmmFrame.ToString()); KmmBody responseKmmBody = responseKmmFrame.KmmBody; if (responseKmmBody is DeleteAuthenticationKeyResponse) { Output.DebugLine("received DeleteAuthenticationKeyResponse kmm"); DeleteAuthenticationKeyResponse deleteAuthenticationKeyResponse = responseKmmBody as DeleteAuthenticationKeyResponse; Output.DebugLine("response kmm body - {0}", deleteAuthenticationKeyResponse.ToString()); Output.DebugLine("response suid - {0}", deleteAuthenticationKeyResponse.SuId.ToString()); if (deleteAuthenticationKeyResponse.Status == Status.CommandWasPerformed) { return(0); } else { Output.ErrorLine("abnormal response - status: {0} (0x{1:X2})", deleteAuthenticationKeyResponse.Status.ToString(), (byte)deleteAuthenticationKeyResponse.Status); return(-1); } } else if (responseKmmBody is NegativeAcknowledgement) { Output.ErrorLine("received NegativeAcknowledgement kmm"); NegativeAcknowledgement negativeAcknowledgement = responseKmmBody as NegativeAcknowledgement; Output.DebugLine("response kmm body - {0}", negativeAcknowledgement.ToString()); return(-1); } else { Output.ErrorLine("received unexpected kmm"); return(-1); } }
public static int ListSuIdItems() { Output.DebugLine("ListSuIdItems()"); bool needsAnotherRun = true; int inventoryMarker = 0; while (needsAnotherRun) { InventoryCommandListSuIdItems commandKmmBody = new InventoryCommandListSuIdItems(inventoryMarker, 59); Output.DebugLine("command kmm body - {0}", commandKmmBody.ToString()); KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); Output.DebugLine("command kmm frame - {0}", commandKmmFrame.ToString()); byte[] toRadio = commandKmmFrame.ToBytes(); byte[] fromRadio; try { fromRadio = Network.QueryRadio(toRadio); } catch (Exception ex) { Output.ErrorLine("unable to connect to radio: {0}", ex.Message); return(-1); } KmmFrame responseKmmFrame = new KmmFrame(fromRadio); Output.DebugLine("response kmm frame - {0}", responseKmmFrame.ToString()); KmmBody responseKmmBody = responseKmmFrame.KmmBody; if (responseKmmBody is InventoryResponseListSuIdItems) { Output.DebugLine("received InventoryResponseListSuIdItems kmm"); InventoryResponseListSuIdItems inventoryResponseListSuIdItems = responseKmmBody as InventoryResponseListSuIdItems; Output.DebugLine("response kmm body - {0}", inventoryResponseListSuIdItems.ToString()); inventoryMarker = inventoryResponseListSuIdItems.InventoryMarker; Output.DebugLine("inventory marker - {0}", inventoryMarker); if (inventoryMarker > 0) { needsAnotherRun = true; } else { needsAnotherRun = false; } foreach (SuIdStatus responseSuIdStatus in inventoryResponseListSuIdItems.SuIdStatuses) { Output.InfoLine("WACN: 0x{0:X}, System: 0x{1:X}, Unit: 0x{2:X}, Key Assigned: {3}, Is Active: {4}", responseSuIdStatus.SuId.WacnId, responseSuIdStatus.SuId.SystemId, responseSuIdStatus.SuId.UnitId, responseSuIdStatus.KeyAssigned, responseSuIdStatus.ActiveSuId); } } else if (responseKmmBody is NegativeAcknowledgement) { Output.ErrorLine("received NegativeAcknowledgement kmm"); NegativeAcknowledgement negativeAcknowledgement = responseKmmBody as NegativeAcknowledgement; Output.DebugLine("response kmm body - {0}", negativeAcknowledgement.ToString()); return(-1); } else { Output.ErrorLine("received unexpected kmm"); return(-1); } } return(0); }
public static int ListActiveSuId() { Output.DebugLine("ListActiveSuId()"); InventoryCommandListActiveSuId commandKmmBody = new InventoryCommandListActiveSuId(); Output.DebugLine("command kmm body - {0}", commandKmmBody.ToString()); KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); Output.DebugLine("command kmm frame - {0}", commandKmmFrame.ToString()); byte[] toRadio = commandKmmFrame.ToBytes(); byte[] fromRadio; try { fromRadio = Network.QueryRadio(toRadio); } catch (Exception ex) { Output.ErrorLine("unable to connect to radio: {0}", ex.Message); return(-1); } KmmFrame responseKmmFrame = new KmmFrame(fromRadio); Output.DebugLine("response kmm frame - {0}", responseKmmFrame.ToString()); KmmBody responseKmmBody = responseKmmFrame.KmmBody; if (responseKmmBody is InventoryResponseListActiveSuId) { Output.DebugLine("received InventoryResponseListActiveSuId kmm"); InventoryResponseListActiveSuId inventoryResponseListActiveSuId = responseKmmBody as InventoryResponseListActiveSuId; Output.DebugLine("response kmm body - {0}", inventoryResponseListActiveSuId.ToString()); Output.DebugLine("response suid - {0}", inventoryResponseListActiveSuId.SuId.ToString()); if (inventoryResponseListActiveSuId.Status == Status.CommandWasPerformed) { Output.InfoLine("WACN: 0x{0:X}, System: 0x{1:X}, Unit: 0x{2:X}, Key Assigned: {3}, Is Active: {4}", inventoryResponseListActiveSuId.SuId.WacnId, inventoryResponseListActiveSuId.SuId.SystemId, inventoryResponseListActiveSuId.SuId.UnitId, inventoryResponseListActiveSuId.KeyAssigned, inventoryResponseListActiveSuId.ActiveSuId); return(0); } else { Output.ErrorLine("abnormal response - status: {0} (0x{1:X2})", inventoryResponseListActiveSuId.Status.ToString(), (byte)inventoryResponseListActiveSuId.Status); return(-1); } } else if (responseKmmBody is NegativeAcknowledgement) { Output.ErrorLine("received NegativeAcknowledgement kmm"); NegativeAcknowledgement negativeAcknowledgement = responseKmmBody as NegativeAcknowledgement; Output.DebugLine("response kmm body - {0}", negativeAcknowledgement.ToString()); return(-1); } else { Output.ErrorLine("received unexpected kmm"); return(-1); } }
public static int LoadAuthenticationKey(bool targetSpecificSuId, int wacnId, int systemId, int unitId, byte[] key) { Output.DebugLine("LoadAuthenticationKey() :: targetSpecificSuId: {0}, wacnId: 0x{1:X}, systemId: 0x{2:X}, unitId: 0x{3:X}, key (hex): {4}", targetSpecificSuId, wacnId, systemId, unitId, BitConverter.ToString(key)); SuId commandSuId = new SuId(wacnId, systemId, unitId); Output.DebugLine("command suid - {0}", commandSuId.ToString()); LoadAuthenticationKeyCommand commandKmmBody = new LoadAuthenticationKeyCommand(targetSpecificSuId, commandSuId, key); Output.DebugLine("command kmm body - {0}", commandKmmBody.ToString()); KmmFrame commandKmmFrame = new KmmFrame(commandKmmBody); Output.DebugLine("command kmm frame - {0}", commandKmmFrame.ToString()); byte[] toRadio = commandKmmFrame.ToBytes(); byte[] fromRadio; try { fromRadio = Network.QueryRadio(toRadio); } catch (Exception ex) { Output.ErrorLine("unable to connect to radio: {0}", ex.Message); return(-1); } KmmFrame responseKmmFrame = new KmmFrame(fromRadio); Output.DebugLine("response kmm frame - {0}", responseKmmFrame.ToString()); KmmBody responseKmmBody = responseKmmFrame.KmmBody; if (responseKmmBody is LoadAuthenticationKeyResponse) { Output.DebugLine("received LoadAuthenticationKeyResponse kmm"); LoadAuthenticationKeyResponse loadAuthenticationKeyResponse = responseKmmBody as LoadAuthenticationKeyResponse; Output.DebugLine("response kmm body - {0}", loadAuthenticationKeyResponse.ToString()); Output.DebugLine("response suid - {0}", loadAuthenticationKeyResponse.SuId.ToString()); if (loadAuthenticationKeyResponse.AssignmentSuccess == true && loadAuthenticationKeyResponse.Status == Status.CommandWasPerformed) { return(0); } else { Output.ErrorLine("abnormal response - assignment success: {0}, status: {1} (0x{2:X2})", loadAuthenticationKeyResponse.AssignmentSuccess, loadAuthenticationKeyResponse.Status.ToString(), (byte)loadAuthenticationKeyResponse.Status); return(-1); } } else if (responseKmmBody is NegativeAcknowledgement) { Output.ErrorLine("received NegativeAcknowledgement kmm"); NegativeAcknowledgement negativeAcknowledgement = responseKmmBody as NegativeAcknowledgement; Output.DebugLine("response kmm body - {0}", negativeAcknowledgement.ToString()); return(-1); } else { Output.ErrorLine("received unexpected kmm"); return(-1); } }
public void MrRunProducer() { try { while (true) { byte rx; /* RX: KEY SIGNATURE */ // currently there is no rx key signature function in the adapter // however, the key signature will appear as a 0x00 byte // the 5 second timeout should prevent most sync issues, however // a rx key signature function should be added to the adapter // to make this more robust and correct Log.Debug("in: waiting for key signature"); rx = Protocol.GetByte(TIMEOUT_NONE); Log.Trace("in: {0}", Utility.DataFormat(rx)); byte sig = 0x00; // key signature if (rx == sig) { Log.Debug("in: got key signature"); } else { string msg = string.Format("in: unexpected key signature opcode, expected ({0}) got ({1})", Utility.DataFormat(sig), Utility.DataFormat(rx)); Log.Warn(msg); continue; } /* RX: READY REQUEST */ try { Log.Debug("in: waiting for ready request opcode"); rx = Protocol.GetByte(TIMEOUT_STD); Log.Trace("in: {0}", Utility.DataFormat(rx)); } catch (Exception) { string msg = string.Format("in: timed out waiting for ready request opcode"); Log.Warn(msg); continue; } if (rx == OPCODE_READY_REQ) { Log.Debug("in: got ready request opcode"); } else { string msg = string.Format("in: unexpected ready request opcode, expected ({0}) got ({1})", Utility.DataFormat(OPCODE_READY_REQ), Utility.DataFormat(rx)); Log.Warn(msg); continue; } /* TX: READY GENERAL MODE */ Log.Debug("out: ready general mode opcode"); Log.Trace("out: {0}", Utility.DataFormat(OPCODE_READY_GENERAL_MODE)); Protocol.SendByte(OPCODE_READY_GENERAL_MODE); while (true) { /* RX: FRAME TYPE */ try { Log.Debug("in: waiting for frame type opcode"); rx = Protocol.GetByte(TIMEOUT_STD); Log.Trace("in: {0}", Utility.DataFormat(rx)); } catch (Exception) { string msg = string.Format("in: timed out waiting for frame type opcode"); Log.Warn(msg); break; } if (rx == OPCODE_KMM) { Log.Debug("in: got kmm opcode"); List <byte> rxFrame; try { rxFrame = ParseKmmFrame(); } catch (Exception ex) { Log.Warn(ex.Message); break; } KmmFrame kfdKmmFrame = null; try { kfdKmmFrame = new KmmFrame(rxFrame.ToArray()); } catch (Exception ex) { Log.Warn(ex.Message); byte[] message = rxFrame.ToArray(); if (message.Length != 0) { Log.Warn("unexpected message id: {0} (dec), {0:X} (hex)", message[0]); NegativeAcknowledgment kmm = new NegativeAcknowledgment(); kmm.AcknowledgedMessageId = (MessageId)message[0]; kmm.Status = AckStatus.InvalidMessageId; KmmFrame frame = new KmmFrame(kmm); SendKmm(frame.ToBytes()); } continue; } KmmBody kfdKmmBody = kfdKmmFrame.KmmBody; if (kfdKmmBody is InventoryCommandListActiveKsetIds) { InventoryResponseListActiveKsetIds mrKmm = new InventoryResponseListActiveKsetIds(); // do not return any keysets, to match factory Motorola SU behavior KmmFrame commandKmmFrame = new KmmFrame(mrKmm); SendKmm(commandKmmFrame.ToBytes()); } else if (kfdKmmBody is ModifyKeyCommand) { ModifyKeyCommand cmdKmm = kfdKmmBody as ModifyKeyCommand; Log.Debug("keyset id: {0} (dec), {0:X} (hex)", cmdKmm.KeysetId); Log.Debug("algorithm id: {0} (dec), {0:X} (hex)", cmdKmm.AlgorithmId); RekeyAcknowledgment rspKmm = new RekeyAcknowledgment(); rspKmm.MessageIdAcknowledged = MessageId.ModifyKeyCommand; rspKmm.NumberOfItems = cmdKmm.KeyItems.Count; for (int i = 0; i < cmdKmm.KeyItems.Count; i++) { KeyItem item = cmdKmm.KeyItems[i]; Log.Debug("* key item {0} *", i); Log.Debug("erase: {0}", item.Erase); Log.Debug("sln: {0} (dec), {0:X} (hex)", item.SLN); Log.Debug("key id: {0} (dec), {0:X} (hex)", item.KeyId); Log.Debug("key: {0}", BitConverter.ToString(item.Key)); string algName = string.Empty; if (Enum.IsDefined(typeof(AlgorithmId), (byte)cmdKmm.AlgorithmId)) { algName = ((AlgorithmId)cmdKmm.AlgorithmId).ToString(); } else { algName = "UNKNOWN"; } Status += string.Format("Keyset ID: {0} (dec), {0:X} (hex)", cmdKmm.KeysetId) + Environment.NewLine + string.Format("SLN/CKR: {0} (dec), {0:X} (hex)", item.SLN) + Environment.NewLine + string.Format("Key ID: {0} (dec), {0:X} (hex)", item.KeyId) + Environment.NewLine + string.Format("Algorithm: {0} (dec), {0:X} (hex), {1}", cmdKmm.AlgorithmId, algName) + Environment.NewLine + string.Format("Key: {0}", BitConverter.ToString(item.Key).Replace("-", string.Empty)) + Environment.NewLine + "--" + Environment.NewLine; KeyStatus status = new KeyStatus(); status.AlgorithmId = cmdKmm.AlgorithmId; status.KeyId = item.KeyId; status.Status = 0x00; // command was performed rspKmm.Keys.Add(status); } KmmFrame cmdKmmFrame = new KmmFrame(rspKmm); SendKmm(cmdKmmFrame.ToBytes()); } } else if (rx == OPCODE_TRANSFER_DONE) { Log.Debug("in: got transfer done opcode"); /* TX: TRANSFER DONE */ Log.Debug("out: transfer done opcode"); Log.Trace("out: {0}", Utility.DataFormat(OPCODE_TRANSFER_DONE)); Protocol.SendByte(OPCODE_TRANSFER_DONE); /* RX: DISCONNECT */ try { Log.Debug("in: waiting for disconnect opcode"); rx = Protocol.GetByte(TIMEOUT_STD); Log.Trace("in: {0}", Utility.DataFormat(rx)); } catch (Exception) { string msg = string.Format("in: timed out waiting for disconnect opcode"); Log.Warn(msg); break; } if (rx == OPCODE_DISCONNECT) { Log.Debug("in: got disconnect opcode"); } else { string msg = string.Format("in: unexpected disconnect opcode, expected ({0}) got ({1})", Utility.DataFormat(OPCODE_DISCONNECT), Utility.DataFormat(rx)); Log.Warn(msg); break; } /* TX: DISCONNECT ACKNOWLEDGE */ Log.Debug("out: disconnect acknowledge opcode"); Log.Trace("out: {0}", Utility.DataFormat(OPCODE_DISCONNECT_ACK)); Protocol.SendByte(OPCODE_DISCONNECT_ACK); break; } else { string msg = string.Format("in: unexpected frame type opcode ({0})", Utility.DataFormat(rx)); Log.Warn(msg); break; } } } } catch (OperationCanceledException) { Log.Debug("operation cancelled"); return; } catch (Exception ex) { Log.Warn("error in mr emulation: {0}", ex.Message); throw; } }