Exemple #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="value"></param>
        /// <param name="targetType"></param>
        /// <param name="parameter"></param>
        /// <param name="culture"></param>
        /// <returns></returns>
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value == null)
            {
                return(null);
            }

            SearchPolicy source = (SearchPolicy)Enum.Parse(typeof(SearchPolicy), value.ToString());
            string       target;

            switch (source)
            {
            case SearchPolicy.Global:
            default:
                target = SearchPolicy_Global;
                break;

            case SearchPolicy.Partial:
                target = SearchPolicy_Partial;
                break;

            case SearchPolicy.Individual:
                target = SearchPolicy_Individual;
                break;
            }

            return(target);
        }
Exemple #2
0
        static void AttackLastRound()
        {
            Encryption encryption = new Encryption();
            Analysis   analysis   = new Analysis();

            Console.WriteLine("Current keys: " + encryption.PrintKeys());

            //analysis the sbox
            List <Differential> diffList = analysis.CountDifferentialsSingleSBox();

            bool[] attackSBox = new bool[] { true };

            //Check the attack new
            CipherThreeDifferentialKeyRecoveryAttack keyRecoveryConfiguration = new CipherThreeDifferentialKeyRecoveryAttack();

            SearchPolicy   curSearchPolicy   = SearchPolicy.FirstBestCharacteristicDepthSearch;
            AbortingPolicy curAbortingPolicy = AbortingPolicy.Threshold;

            //attack round 3
            DifferentialAttackRoundConfiguration configRound3SBox1 = analysis.GenerateConfigurationAttack(3, attackSBox, curAbortingPolicy, curSearchPolicy, diffList, keyRecoveryConfiguration, encryption);
            DifferentialAttackRoundResult        resultRound3SBox1 = analysis.RecoverKeyInformation(keyRecoveryConfiguration, configRound3SBox1, encryption);

            keyRecoveryConfiguration.RoundConfigurations.Add(configRound3SBox1);
            keyRecoveryConfiguration.RoundResults.Add(resultRound3SBox1);

            //Result
            keyRecoveryConfiguration.Subkey3          = resultRound3SBox1.PossibleKey;
            keyRecoveryConfiguration.RecoveredSubkey3 = true;
            Console.WriteLine(keyRecoveryConfiguration.printRecoveredSubkeyBits());
        }
Exemple #3
0
        public JsonResult SearchPolicy(SearchPolicy search, int page, int rows)
        {
            PagedList <ResponsePolicy> pagedList = null;

            CommunicateManager.Invoke <IConsoLocalPolicyService>(p =>
            {
                pagedList = p.FindPolicyByPager(search, page, rows);
            });
            if (pagedList == null)
            {
                pagedList = new PagedList <ResponsePolicy>();
            }
            return(Json(new { total = pagedList.Total, rows = pagedList.Rows }, JsonRequestBehavior.AllowGet));
        }
Exemple #4
0
        /// <summary>
        /// Creates a control panel
        /// </summary>
        public ControlPanel()
        {
            U.L(LogLevel.Debug, "CONTROL PANEL", "Initialize");
            InitializeComponent();
            U.L(LogLevel.Debug, "CONTROL PANEL", "Initialized");

            openAddPolicy = SettingsManager.OpenAddPolicy;
            openFilePlay = SettingsManager.OpenPlayPolicy;
            upgradePolicy = SettingsManager.UpgradePolicy;
            searchPolicy = SettingsManager.SearchPolicy;

            this.DataContext = this;

            tabs.Add(Tab.General, ControlPanelGeneral);
            tabs.Add(Tab.Sources, ControlPanelSources);
            tabs.Add(Tab.Services, Services);
            tabs.Add(Tab.Plugins, Plugins);
            tabs.Add(Tab.Shortcuts, ControlPanelShortcuts);
            tabs.Add(Tab.About, ControlPanelAbout);
            tabLinks.Add(Tab.General, ControlPanelLink_General);
            tabLinks.Add(Tab.Sources, ControlPanelLink_Sources);
            tabLinks.Add(Tab.Services, ControlPanelLink_Services);
            tabLinks.Add(Tab.Plugins, ControlPanelLink_Plugins);
            tabLinks.Add(Tab.Shortcuts, ControlPanelLink_Shortcuts);
            tabLinks.Add(Tab.About, ControlPanelLink_About);

            menuRemove = new MenuItem();
            menuRemove.Header = U.T("MenuRemove");
            menuRemove.Click += new RoutedEventHandler(menuRemove_Click);

            menuToggle = new MenuItem();
            menuToggle.Header = U.T("MenuIgnore");
            menuToggle.Click += new RoutedEventHandler(menuToggle_Click);

            sourceMenu = new ContextMenu();
            sourceMenu.Items.Add(menuToggle);
            sourceMenu.Items.Add(menuRemove);

            SourceList.ContextMenu = sourceMenu;

            SettingsManager.PropertyChanged += new PropertyChangedWithValuesEventHandler(SettingsManager_PropertyChanged);

            U.L(LogLevel.Debug, "CONTROL PANEL", "Created");
        }
        void obradi()
        {
            try
            {
                int operacija = 0;
                while (operacija != (int)Operacije.Kraj)
                {
                    TransferKlasa transfer = formater.Deserialize(tok) as TransferKlasa;
                    switch (transfer.Operacija)
                    {
                    case Operacije.Login:
                        FindAgent fa = new FindAgent();
                        transfer.Rezultat = fa.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.AddClient:
                        AddClient ac = new AddClient();
                        transfer.Rezultat = ac.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.GetListClients:
                        GetLIstClients glc = new GetLIstClients();
                        transfer.Rezultat = glc.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.SearchClients:
                        SearchClients sc = new SearchClients();
                        transfer.Rezultat = sc.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.SelectClient:
                        SelectClient scl = new SelectClient();
                        transfer.Rezultat = scl.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.UpdateClient:
                        UpdateClient uc = new UpdateClient();
                        transfer.Rezultat = uc.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.AddPolicy:
                        AddPolicy ap = new AddPolicy();
                        transfer.Rezultat = ap.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.UpdatePolicy:
                        UpdatePolicy up = new UpdatePolicy();
                        transfer.Rezultat = up.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.DeletePolicy:
                        DeletePolicy dp = new DeletePolicy();
                        transfer.Rezultat = dp.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.SearchPolicy:
                        SearchPolicy sp = new SearchPolicy();
                        transfer.Rezultat = sp.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.SelectPolicy:
                        SelectPolicy spo = new SelectPolicy();
                        transfer.Rezultat = spo.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.GetListInsTypes:
                        GetListInsuranceTypes git = new GetListInsuranceTypes();
                        transfer.Rezultat = git.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.DeleteClient:
                        DeleteClient dc = new DeleteClient();
                        transfer.Rezultat = dc.IzvrsiSO(transfer.TransferObjekat as OpstiDomenskiObjekat);
                        formater.Serialize(tok, transfer);
                        break;

                    case Operacije.Kraj:
                        operacija = 1;
                        Server.listaTokova.Remove(tok);
                        break;

                    default:
                        break;
                    }
                }
            }
            catch (Exception)
            {
                Server.listaTokova.Remove(tok);
            }
        }
Exemple #6
0
        public DifferentialAttackRoundConfiguration GenerateConfigurationAttack(int round, bool[] sBoxesToAttack, AbortingPolicy abortingPolicy, SearchPolicy searchPolicy, List <Differential> diffListOfSBox, DifferentialKeyRecoveryAttack attack, IEncryption encryption)
        {
            if (round <= 1)
            {
                throw new ArgumentException("To attack round 1, use AttackFirstRound()");
            }
            else if (sBoxesToAttack == null)
            {
                throw new ArgumentException("At least one SBox must be specified to attack");
            }

            DifferentialAttackRoundConfiguration result = new DifferentialAttackRoundConfiguration
            {
                ActiveSBoxes   = sBoxesToAttack,
                Round          = round,
                AbortingPolicy = abortingPolicy,
                SearchPolicy   = searchPolicy
            };

            int    inputDifference                    = -1;
            int    expectedDifference                 = -1;
            double probabilityAccumulated             = 0.0;
            List <Characteristic> bestCharacteristics = null;

            if (result.Round == 3)
            {
                result.IsLast = true;
            }
            else if (result.Round == 2)
            {
                result.IsBeforeLast = true;
            }

            List <Characteristic> characteristics = FindBestCharacteristicsDepthSearch(result, diffListOfSBox);

            //Delete Characteristics which are not usable
            List <Characteristic> toDelete = new List <Characteristic>();

            foreach (var curCharacteristic in characteristics)
            {
                bool[] conditionArray = new bool[CipherThreeConfiguration.SBOXNUM];

                for (int i = 0; i < CipherThreeConfiguration.SBOXNUM; i++)
                {
                    conditionArray[i] = true;

                    if (sBoxesToAttack[i])
                    {
                        if (GetSubBlockFromBlock(curCharacteristic.InputDifferentials[round - 1], i) == 0)
                        {
                            conditionArray[i] = false;
                        }
                    }
                }

                for (int i = 0; i < CipherThreeConfiguration.SBOXNUM; i++)
                {
                    if (conditionArray[i] == false)
                    {
                        toDelete.Add(curCharacteristic);
                    }
                }
            }

            //delete unusable characteristics
            foreach (var characteristicToDelete in toDelete)
            {
                characteristics.Remove(characteristicToDelete);
            }



            foreach (var characteristic in characteristics)
            //Parallel.ForEach(characteristics, (characteristic) =>
            {
                List <Characteristic> differentialList = FindSpecifiedDifferentialDepthSearch(characteristic.InputDifferentials[0], characteristic.InputDifferentials[round - 1], round, diffListOfSBox);

                if (differentialList.Count == 0)
                {
                    //return;
                    continue;
                }

                double testProbability = 0.0;

                foreach (var curCharacteristic in differentialList)
                {
                    testProbability += curCharacteristic.Probability;
                }

                _semaphoreSlim.Wait();
                try
                {
                    if (testProbability > probabilityAccumulated)
                    {
                        probabilityAccumulated = testProbability;
                        bestCharacteristics    = differentialList;
                        Console.WriteLine("Current best: InputDiff: " + bestCharacteristics[0].InputDifferentials[0] + " ExpectedDiff: " + bestCharacteristics[0].InputDifferentials[2] + " Probability: " + probabilityAccumulated);
                    }
                }
                finally
                {
                    _semaphoreSlim.Release();
                }
            }//);

            inputDifference    = bestCharacteristics[0].InputDifferentials[0];
            expectedDifference = bestCharacteristics[0].InputDifferentials[round - 1];

            result.InputDifference    = inputDifference;
            result.ExpectedDifference = expectedDifference;
            result.Characteristics    = bestCharacteristics;

            //result.Characteristics = new List<Characteristic>();
            //result.Characteristics.Add(bestCharacteristics[0]);
            result.Probability = probabilityAccumulated;

            int pairCount = 16;

            result.UnfilteredPairList = GenerateInputPairList(inputDifference, pairCount);
            //result.FilteredPairList = FilterPairs(result, diffListOfSBox, attack, encryption, expectedDifference);
            result.FilteredPairList = result.UnfilteredPairList;

#if DEBUG
            Console.WriteLine("Generated " + result.UnfilteredPairList.Count + " pairs and there stayed " + result.FilteredPairList.Count + " filtered pairs");
#endif

            return(result);
        }
        public bool FocusPrev(SearchPolicy search)
        {
            if (GetNumObjects() > 0)
            {
                // if our focus control is null find the first object near the lower right that can focus
                if (_focusControl == null)
                {
                    GUIControl minCtrl = null;
                    Vector2 minPos = new Vector2(-1e9f, -1e9f);

                    foreach (GUIControl ctrl in Itr<GUIControl>(true))
                    {
                        if (ctrl.Style.Focusable && ctrl.Awake && ctrl.Visible && ctrl.Active)
                        {
                            Vector2 ctrlPos = ctrl.Position;
                            if (ctrlPos.X >= minPos.X && ctrlPos.Y >= minPos.Y)
                            {
                                minCtrl = ctrl;
                                minPos = ctrlPos;
                            }
                        }
                    }

                    SetFocusControl(minCtrl);

                    return minCtrl != null;
                }
                else
                {
                    GUIControl curCtrl = null;
                    Vector2 curPos = new Vector2(-1e9f, -1e9f);

                    RectangleF searchRect = new RectangleF();
                    Vector2 focusPos = _focusControl.Position;
                    Vector2 focusSize = _focusControl.Size;

                    switch (search)
                    {
                        case SearchPolicy.Horizontal:
                            searchRect = new RectangleF(new Vector2(0.0f, focusPos.Y), new Vector2(focusPos.X + focusSize.X, focusSize.Y));
                            break;
                        case SearchPolicy.Vertical:
                            searchRect = new RectangleF(new Vector2(focusPos.X, 0.0f), new Vector2(focusSize.X, focusPos.Y + focusSize.Y));
                            break;
                    }

                    foreach (GUIControl ctrl in Itr<GUIControl>(true))
                    {
                        if (ctrl == _focusControl)
                            continue;

                        if (ctrl.Style.Focusable && ctrl.Awake && ctrl.Visible && ctrl.Active)
                        {
                            if (searchRect.IntersectsWith(ctrl.Bounds))
                            {
                                Vector2 ctrlPos = ctrl.Position;

                                // check for new focus control
                                if ((ctrlPos.X <= focusPos.X && ctrlPos.Y <= focusPos.Y) &&
                                    (ctrlPos.X >= curPos.X && ctrlPos.Y >= curPos.Y))
                                {
                                    curCtrl = ctrl;
                                    curPos = ctrlPos;
                                }
                            }
                        }
                    }

                    SetFocusControl(curCtrl);

                    return curCtrl != null;
                }
            }

            // we didn't find anything
            return false;
        }
        public PagedList <ResponsePolicy> FindPolicyByPager(SearchPolicy search, int page, int rows)
        {
            var code  = AuthManager.GetCurrentUser().Code;
            var query = this.localPolicyRepository.FindAllNoTracking(p => p.Code == code).OfType <LocalNormalPolicy>();

            if (search == null)
            {
                search = new SearchPolicy();
            }
            if (!string.IsNullOrEmpty(search.PolicyType) && !string.IsNullOrEmpty(search.PolicyType.Trim()))
            {
                query = query.Where(p => p.LocalPolicyType == search.PolicyType.Trim());
            }
            if (search.LocalStartPoint.HasValue)
            {
                query = query.Where(p => p.LocalPoint >= search.LocalStartPoint.Value);
            }
            if (search.LocalEndPoint.HasValue)
            {
                query = query.Where(p => p.LocalPoint <= search.LocalEndPoint.Value);
            }
            if (search.PStartTime.HasValue)
            {
                query = query.Where(p => p.PassengeDate.StartTime >= search.PStartTime.Value);
            }
            if (search.PEndTime.HasValue)
            {
                search.PEndTime = search.PEndTime.Value.AddDays(1).AddSeconds(-1);
                query           = query.Where(p => p.PassengeDate.EndTime <= search.PEndTime.Value);
            }
            if (search.Review.HasValue)
            {
                query = query.Where(p => p.Review == search.Review.Value);
            }
            if (!string.IsNullOrEmpty(search.FromCityCode) && !string.IsNullOrEmpty(search.FromCityCode.Trim()))
            {
                query = query.Where(p => p.FromCityCodes.Contains(search.FromCityCode.Trim()));
            }
            if (!string.IsNullOrEmpty(search.ToCityCode) && !string.IsNullOrEmpty(search.ToCityCode.Trim()))
            {
                query = query.Where(p => p.ToCityCodes.Contains(search.ToCityCode.Trim()));
            }
            if (search.TravelType.HasValue)
            {
                query = query.Where(p => p.TravelType == search.TravelType.Value);
            }
            if (search.ReleaseType.HasValue)
            {
                query = query.Where(p => p.ReleaseType == search.ReleaseType.Value);
            }
            if (search.IssueTicketWay.HasValue)
            {
                query = query.Where(p => p.IssueTicketWay == search.IssueTicketWay.Value);
            }
            if (!string.IsNullOrEmpty(search.CarrayCode))
            {
                query = query.Where(p => p.CarrayCode.Equals(search.CarrayCode));
            }
            return(new PagedList <ResponsePolicy>()
            {
                Total = query.Count(),
                Rows = query.OrderByDescending(p => p.CreateDate).Skip((page - 1) * rows).Take(rows).Project().To <ResponsePolicy>().ToList()
            });
        }
Exemple #9
0
 private static extern int sarSmartar_SarRecognizer_sarSetSearchPolicy(IntPtr self, SearchPolicy policy);
Exemple #10
0
 public int SetSearchPolicy(SearchPolicy policy)
 {
     return(sarSmartar_SarRecognizer_sarSetSearchPolicy(self_, policy));
 }
        /// <summary>
        /// Creates a control panel
        /// </summary>
        public ControlPanel()
        {
            //U.L(LogLevel.Debug, "CONTROL PANEL", "Initialize");
            InitializeComponent();
            //U.L(LogLevel.Debug, "CONTROL PANEL", "Initialized");

            openAddPolicy = SettingsManager.OpenAddPolicy;
            openFilePlay = SettingsManager.OpenPlayPolicy;
            upgradePolicy = SettingsManager.UpgradePolicy;
            searchPolicy = SettingsManager.SearchPolicy;

            this.DataContext = this;

            tabs.Add(Tab.General, ControlPanelGeneral);
            tabs.Add(Tab.Sources, Sources);
            tabs.Add(Tab.Services, Services);
            tabs.Add(Tab.Plugins, Plugins);
            tabs.Add(Tab.Shortcuts, ControlPanelShortcuts);
            tabs.Add(Tab.About, ControlPanelAbout);
            tabLinks.Add(Tab.General, ControlPanelLink_General);
            tabLinks.Add(Tab.Sources, ControlPanelLink_Sources);
            tabLinks.Add(Tab.Services, ControlPanelLink_Services);
            tabLinks.Add(Tab.Plugins, ControlPanelLink_Plugins);
            tabLinks.Add(Tab.Shortcuts, ControlPanelLink_Shortcuts);
            tabLinks.Add(Tab.About, ControlPanelLink_About);

            SettingsManager.PropertyChanged += new PropertyChangedWithValuesEventHandler(SettingsManager_PropertyChanged);

            //U.L(LogLevel.Debug, "CONTROL PANEL", "Created");
        }