コード例 #1
0
        public void ReadCard(object ob)
        {
            string          selectedReader         = ob as string;
            ASN1            daTa                   = null;
            List <String[]> la                     = new List <string[]>();
            List <byte[]>   pseIdentifiers         = new List <byte[]>();
            List <byte[]>   applicationIdentifiers = new List <byte[]>();
            ASCIIEncoding   encoding               = new ASCIIEncoding();
            APDUCmd         apdu                   = null;
            APDURes         response               = null;
            bool            pseFound               = false;

            pseIdentifiers.Add(encoding.GetBytes("1PAY.SYS.DDF01"));
            pseIdentifiers.Add(encoding.GetBytes("2PAY.SYS.DDF01"));

            try
            {
                // Now lets process all Payment System Environments
                if (pseIdentifiers.Count > 0)
                {
                    cardReaderList.Connect(selectedReader);
                    foreach (byte[] pse in pseIdentifiers)
                    {
                        apdu     = new APDUCmd(0x00, 0xA4, 0x04, 0x00, pse, (byte)pse.Length);
                        response = cardReaderList.Transmit(apdu);

                        // Get response nescesary
                        if (response.SW1 == 0x61)
                        {
                            apdu     = new APDUCmd(0x00, 0xC0, 0x00, 0x00, null, response.SW2);
                            response = cardReaderList.Transmit(apdu);
                        }

                        // PSE application read found ok
                        if (response.SW1 == 0x90)
                        {
                            pseFound = true;
                            daTa     = new ASN1(response.Data);
                            byte sfi          = new ASN1(response.Data).Find(0x88).Value[0];
                            byte recordNumber = 0x01;
                            byte p2           = (byte)((sfi << 3) | 4);


                            while (response.SW1 != 0x6A && response.SW2 != 0x83)
                            {
                                apdu     = new APDUCmd(0x00, 0xB2, recordNumber, p2, null, 0x00);
                                response = cardReaderList.Transmit(apdu);

                                // Retry with correct length
                                if (response.SW1 == 0x6C)
                                {
                                    apdu     = new APDUCmd(0x00, 0xB2, recordNumber, p2, null, response.SW2);
                                    response = cardReaderList.Transmit(apdu);
                                }

                                if (response.SW1 == 0x61)
                                {
                                    apdu     = new APDUCmd(0x00, 0xC0, 0x00, 0x00, null, response.SW2);
                                    response = cardReaderList.Transmit(apdu);
                                }

                                if (response.Data != null)
                                {
                                    ASN1 aefVal = new ASN1(response.Data);

                                    foreach (ASN1 appTemplate in aefVal)
                                    {
                                        // Check we really have an Application Template
                                        if (appTemplate.Tag[0] == 0x61)
                                        {
                                            applicationIdentifiers.Add(appTemplate.Find(0x4f).Value);
                                        }
                                    }
                                }
                                recordNumber++;
                            }
                        }
                        if (pseFound)
                        {
                            break;
                        }
                    }
                    cardReaderList.Disconnect();
                }

                if (applicationIdentifiers.Count > 0)
                {
                    foreach (byte[] AID in applicationIdentifiers)
                    {
                        List <AppliFileLoc> applicationFileLocators = new List <AppliFileLoc>();
                        StringBuilder       sb = new StringBuilder();
                        cardReaderList.Connect(selectedReader);

                        // Select AID
                        apdu     = new APDUCmd(0x00, 0xA4, 0x04, 0x00, AID, (byte)AID.Length);
                        response = cardReaderList.Transmit(apdu);

                        // Get response nescesary
                        if (response.SW1 == 0x61)
                        {
                            apdu     = new APDUCmd(0x00, 0xC0, 0x00, 0x00, null, response.SW2);
                            response = cardReaderList.Transmit(apdu);
                        }

                        // Application not found
                        if (response.SW1 == 0x6A && response.SW2 == 0x82)
                        {
                            continue;
                        }

                        if (response.SW1 == 0x90)
                        {
                            foreach (byte b in AID)
                            {
                                sb.AppendFormat("{0:X2}", b);
                            }

                            daTa = new ASN1(response.Data);

                            // Get processing options (with empty PDOL)
                            apdu     = new APDUCmd(0x80, 0xA8, 0x00, 0x00, new byte[] { 0x83, 0x00 }, 0x02);
                            response = cardReaderList.Transmit(apdu);

                            // Get response nescesary
                            if (response.SW1 == 0x61)
                            {
                                apdu     = new APDUCmd(0x00, 0xC0, 0x00, 0x00, null, response.SW2);
                                response = cardReaderList.Transmit(apdu);
                            }

                            if (response.SW1 == 0x90)
                            {
                                ASN1 template = new ASN1(response.Data);
                                ASN1 aipVal   = null;
                                ASN1 aflVal   = null;

                                // Primative response (Template Format 1)
                                if (template.Tag[0] == 0x80)
                                {
                                    byte[] tempAIP = new byte[2];
                                    Buffer.BlockCopy(template.Value, 0, tempAIP, 0, 2);
                                    aipVal = new ASN1(0x82, tempAIP);

                                    byte[] tempAFL = new byte[template.Length - 2];
                                    Buffer.BlockCopy(template.Value, 2, tempAFL, 0, template.Length - 2);
                                    aflVal = new ASN1(0x94, tempAFL);
                                }

                                // constructed data object response (Template Format 2)
                                if (template.Tag[0] == 0x77)
                                {
                                    aipVal = template.Find(0x82);
                                    aflVal = template.Find(0x94);
                                }

                                // Chop up AFL's
                                for (int i = 0; i < aflVal.Length; i += 4)
                                {
                                    byte[] AFL = new byte[4];
                                    Buffer.BlockCopy(aflVal.Value, i, AFL, 0, 4);

                                    AppliFileLoc fileLocator = new AppliFileLoc(AFL);
                                    applicationFileLocators.Add(fileLocator);
                                }

                                ASN1 aipafl = new ASN1(response.Data);

                                foreach (AppliFileLoc file in applicationFileLocators)
                                {
                                    int  rec  = file.FirstRecord;// read SDA records
                                    int  lrec = file.LastRecord;
                                    byte p2   = (byte)((file.SFI << 3) | 4);

                                    while (rec <= lrec)
                                    {
                                        apdu     = new APDUCmd(0x00, 0xB2, (byte)rec, p2, null, 0x00);
                                        response = cardReaderList.Transmit(apdu);

                                        // Retry with correct length
                                        if (response.SW1 == 0x6C)
                                        {
                                            apdu     = new APDUCmd(0x00, 0xB2, (byte)rec, p2, null, response.SW2);
                                            response = cardReaderList.Transmit(apdu);
                                        }

                                        ASN1 record = new ASN1(response.Data);
                                        s_Card(record);
                                        getVal(record);

                                        rec++;
                                    }
                                }
                            }
                            else
                            {
                                UpdateStatusLabel(String.Format("Record not found."));
                            }
                        }
                        else
                        {
                            UpdateStatusLabel(String.Format("File not selected."));
                        }
                        cardReaderList.Disconnect();
                        UpdateStatusLabel(String.Format("Process Complete."));
                    }
                }
            }
            catch (CardDExcep ex)
            {
                UpdateStatusLabel(ex.Message);
                return;
            }
        }
コード例 #2
0
ファイル: MifareRestoreClone.cs プロジェクト: naylamp6/Xploit
        bool InternalRun(bool check)
        {
            byte[] file = System.IO.File.ReadAllBytes(File.FullName);

            using (CardReaderCollection cardReaderCollections = new CardReaderCollection())
                using (CardReader reader = cardReaderCollections[Target.Name])
                {
                    switch (reader.Connect())
                    {
                    case EConnection.Error:
                    {
                        WriteError("Error while connect to " + reader.Name);
                        return(false);
                    }

                    case EConnection.NotCard:
                    {
                        WriteError("Card not present, please insert a card");
                        return(false);
                    }
                    }

                    ICard ic;
                    if (!reader.GetCard(out ic, null))
                    {
                        WriteError("Error while getting card");
                        return(false);
                    }

                    if (ic == null)
                    {
                        WriteError("Please insert a card");
                        return(false);
                    }

                    WriteInfo("Card id ..........", ic.Id.ToString(), ConsoleColor.Cyan);
                    WriteInfo("Card type ........", ic.Type.ToString(), ConsoleColor.Cyan);

                    if (!(ic is CardMifare))
                    {
                        WriteError("Card not is mifare");
                        return(false);
                    }

                    CardMifare card = (CardMifare)ic;
                    WriteInfo("Mifare type ......", card.MifareType.ToString(), ConsoleColor.Cyan);
                    card.InitCard();

                    switch (card.MifareType)
                    {
                    case CardMifare.EMifareType.Classic1K:
                    {
                        int dSec   = card.Sectors[0].DataBlocks[0].Data.Length;
                        int length = card.Sectors.Length * (dSec * 4);       //6 key a / 6 keyb / 4 rights

                        if (file.Length != length)
                        {
                            WriteError("File length must be " + StringHelper.Convert2KbWithBytes(length));
                            return(false);
                        }
                        WriteInfo("Total sectors ....", card.Sectors.Length.ToString(), ConsoleColor.Cyan);

                        length = 0;
                        foreach (CardMifare.Sector sector in card.Sectors)
                        {
                            if (OnlySectors != null && OnlySectors.Count > 0 && !OnlySectors.Contains(sector.SectorNum))
                            {
                                length += dSec * (sector.DataBlocks.Length + 1);
                                WriteInfo("Checking sector " + sector.SectorNum.ToString().PadLeft(2, '0'), "Passed", ConsoleColor.Yellow);
                                continue;
                            }

                            byte[] keyA = new byte[6], keyB = new byte[6];

                            Array.Copy(file, length + (dSec * 3), keyA, 0, 6);
                            Array.Copy(file, length + (dSec * 3) + 10, keyB, 0, 6);

                            ConfigMifareRead cfg = new ConfigMifareRead()
                            {
                                KeysOne = keyA, KeysZero = keyB
                            };

                            ConfigMifareReadSector sec = cfg.ReadSectors[sector.SectorNum];
                            sec.Login = new LoginMifareMethod()
                            {
                                KeyNum  = KeyType == ConfigMifareRead.EKeyType.A ? ConfigMifareRead.EKeyNum.One : ConfigMifareRead.EKeyNum.Zero,
                                KeyType = KeyType
                            };
                            sec.ReadDataBlockEnd   = ConfigMifareReadSector.EBlockRange.DataBlock03;
                            sec.ReadDataBlockStart = ConfigMifareReadSector.EBlockRange.DataBlock01;
                            sec.ReadTrailBlock     = false;

                            ICard c2;
                            if (!reader.GetCard(out c2, cfg))
                            {
                                WriteError("Error reading sector " + sector.SectorNum.ToString() + " Blocks 1-3");
                                return(false);
                            }

                            CardMifare        card2   = (CardMifare)c2;
                            CardMifare.Sector sector2 = card2.Sectors[sector.SectorNum];

                            bool equal = true;
                            foreach (CardMifare.Block block in sector2.DataBlocks)
                            {
                                // Check block
                                bool blockEqual = true;
                                for (int x = 0, m = block.Data.Length; x < m; x++)
                                {
                                    if (block.Data[x] != file[x + length])
                                    {
                                        blockEqual = false; break;
                                    }
                                }

                                if (!blockEqual)
                                {
                                    equal = false;
                                    if (!check)
                                    {
                                        // Write block
                                        byte[] data = new byte[block.Data.Length];
                                        Array.Copy(file, length, data, 0, data.Length);
                                        if (!block.WriteInBlock(reader, cfg, data))
                                        {
                                            WriteError("Error writting sector " + sector2.SectorNum.ToString() + " block " + block.BlockNum.ToString());
                                        }
                                    }
                                }
                                length += block.Data.Length;
                            }

                            // Info
                            if (!equal)
                            {
                                WriteInfo("Checking sector " + sector.SectorNum.ToString().PadLeft(2, '0'), check ? "Different" : "Modified", ConsoleColor.Red);
                            }
                            else
                            {
                                WriteInfo("Checking sector " + sector.SectorNum.ToString().PadLeft(2, '0'), "Equal", ConsoleColor.Green);
                            }

                            length += dSec;       //6 key a / 6 keyb / 4 rights
                        }

                        return(true);
                    }

                    default:
                    {
                        WriteError("Card " + card.MifareType.ToString() + " not implemented");
                        return(false);
                    }
                    }
                }
        }
コード例 #3
0
 public bool IsReaderAvaliable()
 {
     try
     {
         //return SL600DeviceAdapter.GetCardReader().Connect();
         return(reader.Connect());
     }
     catch (Exception)
     {
         return(false);
     }
 }
コード例 #4
0
ファイル: MifareSetId.cs プロジェクト: santatic/Xploit
        bool InternalRun(bool check)
        {
            using (CardReaderCollection cardReaderCollections = new CardReaderCollection())
                using (CardReader reader = cardReaderCollections[Target.Name])
                {
                    switch (reader.Connect())
                    {
                    case EConnection.Error:
                    {
                        WriteError("Error while connect to " + reader.Name);
                        return(false);
                    }

                    case EConnection.NotCard:
                    {
                        WriteError("Card not present, please insert a card");
                        return(false);
                    }
                    }

                    ICard ic;
                    if (!reader.GetCard(out ic, null))
                    {
                        WriteError("Error while getting card");
                        return(false);
                    }

                    if (ic == null)
                    {
                        WriteError("Please insert a card");
                        return(false);
                    }

                    WriteInfo("Card id ..........", ic.Id.ToString(), ConsoleColor.Cyan);
                    WriteInfo("Card type ........", ic.Type.ToString(), ConsoleColor.Cyan);

                    if (!(ic is CardMifare))
                    {
                        WriteError("Card not is mifare");
                        return(false);
                    }

                    CardMifare card = (CardMifare)ic;
                    WriteInfo("Mifare type ......", card.MifareType.ToString(), ConsoleColor.Cyan);
                    card.InitCard();

                    switch (card.MifareType)
                    {
                    case CardMifare.EMifareType.Classic1K:
                    {
                        if (Id == null || Id.Length != 4)
                        {
                            WriteError("Id must be 4 byte length (00:01:02:03:04:05:06:07)");
                            return(false);
                        }

                        if (!check)
                        {
                            ConfigMifareRead cfg = new ConfigMifareRead();
                            cfg.KeysOne = Password;
                            cfg.ReadSectors[0].Login = new LoginMifareMethod()
                            {
                                KeyNum  = ConfigMifareRead.EKeyNum.One,
                                KeyType = KeyType
                            };

                            cfg.ReadSectors[0].ReadDataBlockStart = ConfigMifareReadSector.EBlockRange.DataBlock01;
                            cfg.ReadSectors[0].ReadDataBlockEnd   = ConfigMifareReadSector.EBlockRange.DataBlock03;
                            cfg.ReadSectors[0].ReadTrailBlock     = true;

                            if (reader.GetCard(out ic, cfg))
                            {
                                card = (CardMifare)ic;

                                Array.Copy(Id, 0, card.Sectors[0].DataBlocks[0].Data, 0, Id.Length);
                                if (card.Sectors[0].DataBlocks[0].WriteInBlock(reader, cfg, card.Sectors[0].DataBlocks[0].Data))
                                {
                                    WriteInfo("Sucessfull write!");
                                    return(true);
                                }
                                else
                                {
                                    WriteError("Error while writting sector, check the password");
                                }
                            }

                            return(false);
                        }

                        return(true);
                    }

                    default:
                    {
                        WriteError("Card " + card.MifareType.ToString() + " not implemented");
                        return(false);
                    }
                    }
                }
        }
コード例 #5
0
        public bool PreRun()
        {
            PostRun();

            _Config.ReadSectors[AttackInSectorNum].ReadDataBlockStart = AttackInBlock;
            _Config.ReadSectors[AttackInSectorNum].ReadDataBlockEnd   = AttackInBlock;
            _Config.ReadSectors[AttackInSectorNum].ReadTrailBlock     = false;
            _Config.ReadSectors[AttackInSectorNum].Login = new LoginMifareMethod()
            {
                KeyNum  = ConfigMifareRead.EKeyNum.One,
                KeyType = KeyType
            };

            if (_Targets == null)
            {
                _Targets = MifareRestoreClone.LoadReaders();
            }

            if (_Targets == null)
            {
                WriteError("Not readers detected");
                return(false);
            }

            if (Reader < 0 || Reader >= _Targets.Length)
            {
                WriteInfo("Please select one of this readers in 'Reader' option");

                int ix = 0;
                foreach (Target t in _Targets)
                {
                    WriteInfo(ix.ToString() + " - " + t.Name);
                    ix++;
                }

                return(false);
            }

            _Readers = new CardReaderCollection();
            _Reader  = _Readers[_Targets[0].Name];

            if (_Readers == null)
            {
                WriteError("Not readers detected");
                return(false);
            }

            switch (_Reader.Connect())
            {
            case EConnection.Ok: break;

            case EConnection.NotCard:
            {
                WriteError("Not card present, please insert a card");
                break;
            }
            }

            ICard ic;

            if (!_Reader.GetCard(out ic, null))
            {
                WriteError("Error while getting card");
                return(false);
            }

            if (ic == null)
            {
                WriteError("Please insert a card");
                return(false);
            }

            WriteInfo("Card id ..........", ic.Id.ToString(), ConsoleColor.Cyan);
            WriteInfo("Card type ........", ic.Type.ToString(), ConsoleColor.Cyan);

            if (!(ic is CardMifare))
            {
                WriteError("Card not is mifare");
                return(false);
            }

            _Card = (CardMifare)ic;
            WriteInfo("Mifare type ......", _Card.MifareType.ToString(), ConsoleColor.Cyan);
            _Card.InitCard();

            return(true);
        }