Глава Минкомсвязи предложил Apple и SAP раскрыть свои исходные коды российским специалистам

    На встрече с региональным директором Apple в России Питером Энгробом и генеральным директором SAP в СНГ Вячеславом Ореховым глава Минкомсвязи РФ Николай Никифоров предложил компаниям раскрыть исходные коды своих продуктов российским специалистам.

    Министр проинформировал представителей Apple и SAP о программе сотрудничества ФГУП «НТЦ “Атлас”» (относится к Минкомсвязи) и некоторых зарубежных поставщиков программного обеспечения, в частности, компании Microsoft. В рамках данного проекта российские государственные специалисты ещё в 2003 году начали получать доступ к исходным кодам всей линейки популярных программных продуктов Microsoft. «Такая программа сотрудничества позволяет российским специалистам оперативно изучать новые версии программного обеспечения на предмет наличия в них недекларированных возможностей и оперативно готовить их к сертификации для использования в защищенных контурах информационных систем», — сообщает сайт Минкомсвязи.

    «Разоблачения Эдварда Сноудена в 2013 году и публичные заявления американских спецслужб об усилении слежки за Россией в 2014 году серьезно поставили вопрос доверия зарубежному программному обеспечению и оборудованию, — говорит Никифоров. — Очевидно, что те компании, которые раскрывают исходный код своих программ, ничего не скрывают, а вот те, кто не намеревается наладить сотрудничество с Россией в этом вопросе, могут иметь недекларированные возможности в своих продуктах».
    Share post

    Similar posts

    Comments 109

      –73
      Предложить такое — дебилизм высшего уровня. Позор и печаль :(
        +39
        Мды? Почему же мелкомягкие тогда на это пошли, а яблоку и сапу, мол, позорно то же самое?
          +21
          Потому что продукты мелкомягких используются в госкомпаниях, а это большой кусок для microsoft. Профит от раскрытия исходников Apple сомнительный.
            +18
            Угу. А депутатские айфоны. Сейчас в госкомпаниях уровень яблочности повышен.
              +11
              Думаю apple легко сможет отказаться от 400 — 1000 устройств, что бы не открывать код.
                +16
                Хм. Под этот шумок проводятся достаточно большие закупки. там не 1000 устройств.
                Например программа дистанционного обучения детей инвалидов «почему то» завязана на эпплах. Правда с установленной виндой :)
                Представте Мак мини для детей и аймак для преподавателей с установленой 7-й.
                  +5
                  Все зависит от того посчитает ли эпл, что игра стоит свеч или нет. В майкрософте решили поиграть.
                    –27
                    Очень легко представляю — макмини в базавой комплектации почти неработоспособен. 8 гигов оперативки он съедает в момент, при этом открыт XCode и Chrome c 10 вкладками. При всем при этом, винда8я на нем летает без малейших проблем даже со жрущими память Eclipse/IDEA.
                      0
                      habrastorage.org/files/1b8/dc5/ac9/1b8dc5ac96584b36a2fe08060d2b5a24.png
                      Под виндой, это открыто 4 вкладки(Gmail и 3 вкладки хабра).

                      На маке давно перестал использовать из-за того, что он не чистил память и через N часов занимал 70% памяти.
                      Тем более что сравнить такие вещи объективно невозможно, можно вообще открыть «всего-лишь» просмотр картинки 500К х 800К и сказать что памяти мало.
                        –5
                        Абсолютно согласен. После Снежного Барса OS X пошла по наклонной. Сейчас на моей прошке при загрузке Mavericks съедается больше 3-х гигабайт. При загрузке Windows 8.1 — меньше гигабайта. В дальнейшей работе тот же эффект. И общее впечатление от скорости работы последних версий OS X отрицательное. Раньше эта система и кушала меньше и работала быстрее чем Винда. Сейчас все наоборот. А то, что Хром кушает не по детски — это вопросы к Google скорее.
                          +16
                          Какие еще блин гигабайты при загрузке?? Давайте не будем собирать ерунду всякую.
                          Вот примерно это все (плюс в хроме загружено ~40 вкладок) крутится с аптаймом 48 дней! На Эйре с 4(!!) гигами памяти. О каких утечках вообще может быть речь при таком режиме эксплуатации?
                          Надо бы перезагрузиться, потому что за это время успело выйти 2 обновления.

                            +12
                            Почему-то эффективное использование ОЗУ макосью некоторые воспринимают как излишнее потребление.
                              –1
                              Ну спорить не стану, конечно ) А у меня вот такая картина нарисовалась:

                              image
                                0
                                Подозреваю, что тут дело в том, что макось немного иначе использует память (и соотв. пишет все эти числа). Посмотрите на тот кусок экрана, где написано File cache и т.д.
                                Вот у меня в данный момент memory used == 7.92G, но при этом — app memory == 4.5G.
                            +5
                            Да ну? Mac mini Core 2 Dou 8Gb Ram SSD — рабочая машина. Xcode 5 и 6 попеременно. Постоянно открыто не менее 10 вкладок в Safari. Mail, Skype и куча прочего обычного софта. В iStat отключил иконку памяти чтоб перестать параноидально следить за тем создается ли своп. Свопа нет никогда за редким-редким исключением. И чаще всего этим исключением является сам отлаживаемый софт. Лично мне 8Gb вполне хватает. Есть у меня еще старенький макбук на таком же процессоре, куда больше 4 Gb RAM не ставится. Так вот и там можно работать в таком же режиме с тем же софтом. Своп появляется чаще, но, сам удивляюсь, далеко не всегда.
                              +2
                              Поддерживаю! Mac mini с 8 гигами, на котором и PS с несколькими открытыми макетами, и три браузера с кучей открытых вкладок, и редакторы, и Скайп, и почта. Всё летает.
                              +1
                              www.linuxatemyram.com/ — ваш случай? Вместо Linux поставьте свою любимую OS.
                              +1
                              И на фига там дополнительная сетификация и подтверждение отсутствия бэкдоров? Не гостайна же.
                                +1
                                Помимо ГТ, госрегулированию подвергается обработка и другой информации. Полный перечень — Указ Президента «Об утверждении перечня сведений конфиденциального характера». Для некоторых категорий защищаемой информации сертификат на отсутствие НДВ (недекларированных возможностей) весьма существенен.

                                Кроме того, буквально недавно вышел 31 приказ ФСТЭК по защите АСУ ТП. Не скажу про его требования к составу ИС, но там отсутствие НДВ тоже может быть актуально.
                                  –1
                                  спасибо за ссылки. Однако привычка включать что ни попадя в «защищаемую информацию» — дурная. На бытовые приборы, к которым относится и оборудование для детей, этот список распространяться не должен. А депутаты и прочие гос. служащие, допущенные к гостайне, должны иметь четкую инструкцию, какие устройства могут быть у них в доме. Если айфоны нельзя — ну ОК, значит плохо быть ребенком депутата.
                                    +1
                                    Ну, там и не все, что ни попадя, включено в этот перечень. КМК, вполне себе отвечающий реальности документ.

                                    На бытовые приборы, к которым относится и оборудование для детей, этот список распространяться не должен.


                                    Так там про приборы вообще ни слова нет. Там есть только перечень информации, которая относится к информации ограниченного доступа, не отнесенной к гостайне.

                                    А депутаты и прочие гос. служащие, допущенные к гостайне, должны иметь четкую инструкцию, какие устройства могут быть у них в доме.


                                    А в доме у них может быть, скорее всего, что угодно. При условии, что дома они с какой-то защищаемой информацией не работают. А, к примеру, в контексте защиты ГТ исходники iOS — вообще ни разу не задача первоочередной важности.
                                0
                                Да нет, без винды. Прям на макоси и все мануалы и приложения тоже на макось завязаны.
                                  +1
                                  Например программа дистанционного обучения детей инвалидов «почему то» завязана на эпплах.
                                  — Можно пруф? А то как-то не верится.
                                +2
                                Вроде как продукцию Apple запретили использовать депутатам. Или я что-то путаю?
                                  0
                                  Только стоит там обычно винда :) Сколько не видел маков в госконоторах — все под виндой :)
                                    +1
                                    Возможно требуется специфичный софт, а по внутреннему регламенту антивирус. Кроме того по общим закупкам скорее всего есть только MS Office для windows.
                                      0
                                      Ну да, и операторы ни в чем больше не бачут. Но зачем тогда брать мак :) Впрочем, вопрос риторический :)
                                        0
                                        А какая разница, что покупать за казенное бабло? У вас есть сумма 500 тр, ее нужно освоить за текущий квартал.
                                          +2
                                          Можно докупить что то еще — например проектор или мало ли что. Денег всегда нехватает. Хотя вот такая система с «освоением» это конечно дикость и мрак.
                                  +1
                                  Продукты Эпла тоже используются в госкомпаниях.
                                  А так же в правительстве и парламенте
                                  image
                                  image
                                    +1
                                    Может быть, если запретить Мизулиной пользоваться iPad'ом, она перестанет лезть в наш интернет?
                                      +4
                                      Может быть, стоит выбрать других депутатов?
                                        0
                                        Они сами себя выбрали…
                                          +2
                                          С нашего молчаливого согласия, ну. Гневные комментарии в бложиках за несогласие не считаются :)
                                            0
                                            если не скатываться в излишнюю конкретику, которая на эту тему на Хабре запрещена, то проблем две:
                                            1) отсутствие единого мнения по поводу необходимости свободы слова и контроля за депутатами
                                            2) невозможность договориться о солидарных действиях до победы (типа того, что сделали рабочие в одном отдельно взятом Пикалево).

                                            «Единое мнение» — это, хотя бы, 95% работников ИТ-сферы в России, а не 1000 фолловеров в твиттере и не 300 комментаторов на Хабре.
                                            0
                                            они думаю да — на выборы они скорее всего ходили. А помогали им в этом те кто не ходил — т.е. очень многие
                                      0
                                      Ну, во-первых тут речь не только о яблоке, про сап то не забывайте.
                                      А во-вторых да, чиновье то видать тоже хочет айфонами пользоваться, а не сертифицироваными в ФСБ андроидами :)

                                      Строго говоря да, профит невелик, но пуркуа бы не па? Хотите продавать айфоны в думу и прочим — давайте сорцы.
                                        +3
                                        Вопросов нет. Только интересно, что они будут делать, когда в apple им откажут? Неужто перейдут на на православный сертифицированный русский смартфон на андройде?
                                          +1
                                          Уже перешли на samsung. Тот же Никифоров объявлял.
                                            +2
                                            Примут какой-нибудь закон о запрете импорта или повышенных пошлинах для не прошедших сертификацию в ФСБ гаджетов, делов-то.
                                              +3
                                              Он уже есть, нельзя ввозить устройства шифрования\связи, которые не имеют нотификацию ФСБ.
                                                0
                                                Я конечно могу ошибаться, но вроде как нужна сертификация от ФСТЭК, а не от ФСБ.
                                                  0
                                                  По криптографии — это именно ФСБ. ФСТЭК криптуху в свое время не отжал :)
                                                    0
                                                    Вы все правильно написали.
                                                    Мой косяк в том, что я думал именно о гаджетах и о системном или прикладном ПО, но не о криптографии.
                                                    В общем, не на тот ответ я вставил свой комментарий.

                                                    Прошу всех простить мне мою невнимательность.
                                                      +1
                                                      На самом деле, вопрос зоны ответственности разных регуляторов — это та еще камасутра. Круче может быть только изучение исторических причин, почему они (зоны ответственности) разделились между ними (регуляторами) так, а не иначе.
                                                  0
                                                  Есть еще интересные варианты, особенно касающиеся госкомпаний, но и может затронуть обычных ремонтников. Например, обязательное лицензирование деятельности, связанной с шифровальными средствами. А еще лицензия на деятельность по защите конфидециальной информации.
                                                  А даже если это все есть в казенной организации, могут заставить получать сертификат соответствия внутренней сети на защищенность.
                                          0
                                          в статье не указано, кто к кому пришел. По логике — apple с sap пришли к минсвязи проситься в госзаказ.
                                          Им просто озвучили условия.
                                          опять же — раскрытие ТОЛЬКО специалистам. ну можно про сертификацию фстэк почитать.
                                          и список сертифицированного ФСТЭК посмотреть.
                                        +8
                                        Не считаю это дебилизмом. В случае когда такой софт используется в системах от которых зависит моя жизь/безопасность и всех жителей страны — я за то, чтобы спец. службы знали что внутри этого софта. Конечно, «пусть не используют и свё!» будете кричать вы, но если есть возможность договориться и использовать, то почему бы и нет…

                                        > Предложить такое — дебилизм высшего уровня. Позор и печаль :(
                                        Сомнительное и странное заявление как минимум.
                                          –12
                                          Это ваше мнение. Ок, а то, сверху — мое. Вам не обязательно оспаривать его.
                                            –10
                                            Полагаю, в текущей политической ситуации, открытие исходников ударит по акциям намного сильнее, чем даже полный уход с российского рынка.
                                            Потому предложение «не пользуйтесь, если не уверенны в безопасности» актуально. Запретить apple все равно не получится, это все равно что запретить youtube. Просто продукция пойдет серыми схемами, Эпплу без разницы, государству — потери.

                                            Плохой покер тут получается, имхо.
                                              –2
                                              И давно у нас ядерные реакторы работают на OS X?
                                              Во всех иных случах не надо тут гнать про чью-то безопасность.
                                                +1
                                                А при чем здесь ядерные ракеты?
                                                  +2
                                                  Взаимный вопрос, а при чем тут ядерные ракеты? :D
                                                    0
                                                    Хм… Да уж. Наш мозг очень интересная штуковина.
                                                    Да, сути вопроса это не меняет. Я не писал ни про ракеты на iOS ни про реакторы на ней. Из без них полно железа и на iOS в том числе, которые должны быть безопасны, чтобы мой зад чувствовал себя в безопасности.)
                                              +1
                                              Это троллинг 80 lvl.
                                                0
                                                погуглите «сертификация ФСТЭК», «список сертифицированного ПО ФСТЭК».
                                                +36
                                                Тем временем в офисах Apple и SAP.

                                                  –3
                                                    –6
                                                    Грамотно ответили. :-)
                                                    0
                                                    Данную картинку можно в пост вставлять, более чем уверен, что реакция будет именно такая.
                                                      +5
                                                      Чтож тогда вообще на встречу пришли, раз они такие крутые и им смешно?
                                                      Не знаю как там насчет яблочников, а SAP задумается мне кажется.
                                                        +4
                                                        SAP однозначно задумается и сделает шаги в сторону минсвязи. Российские крупные компании очень плотно с ним работают, а порой и первыми опробывают новые продукты и делают бета тесты.

                                                          +1
                                                          а есть статистика, какой процент выручки SAP приходится на Россию? Для большинства компаний уровня Oracle это — не больше 2%. IMHO.
                                                      –7
                                                      Гансу Ланде тоже эту новость рассказали

                                                        +8
                                                        Еще парочку видеороликов и картинок пожалуйста, а то с первого раза не все поняли.
                                                        +1
                                                        Хабр превратился в имиджборду?
                                                          0
                                                          поддерживаю!
                                                        +1
                                                        del
                                                          +5
                                                          А почему в списке нет Oracle и IBM или они исходники уже давно слили?
                                                            –8
                                                            Мне рассказывали, что был момент когда Oracle раскрыл свои сорцы Сберу (в мохнатых годах). Ни черта не поняли. Не думаю, что тут будет другая ситуация
                                                              0
                                                              судя по тому, что на довольно старой версии oracle построены системы, которым доверяют «секретные» финансы нашй страны, видимо, какую-то версию сертифицировали
                                                                +1
                                                                Свемел сделал Циркон 10 на основе Solaris 10 Trusted Extensions. Свемелу Sun исходники открыл. И до того просто Циркон был сделан на основе Trusted Solaris 8 — на тех же условиях. Правда, во времена Solaris 10 код Solaris и так был уже на 95% публично открыт. Про IBM — не знаю. Циркон используется в МинОбороны.
                                                                +3
                                                                Интересно что смогли найти специалисты в исходниках microsoft, если в таких крупных продуктах узявимости будут находится до тех пор, пока в этом заинтересованы иследователи по информационной безопасности.
                                                                Как говорится 100% безопасных продуктов не бывает.
                                                                  +4
                                                                  Там ищут в первую очередь, я думаю, спецательно оставленные бэкдоры. Хотя, конечно, иногда бэкдор очень грамотно маскируется под багу и его годами не могут найти (как в IPSEC в OpenBSD, вроде).

                                                                  И еще вопрос — а тот ли исходный код используется для сборки образов той же винды, который показывают нашим чекистам? Или у них свои, сляпаные из этих исходников, сборки винды? :)
                                                                    –7
                                                                    Думаю они не просто отдают голый код на проверку. Наши чиновники хотя и очень интересные, но не настолько простые. Скорее всего дается некий аппаратный комплекс способный скомпилировать отдельные части дистрибутива, которые потом по контрольным суммам можно сравнить с частями дистрибутива купленного в магазине.
                                                                      0
                                                                      Вот уж вряд ли. Скорее, просто могут проверить то, чем сами будут пользоваться. Кого волнует, что продается в магазине?
                                                                      +3
                                                                      И еще вопрос — а тот ли исходный код используется для сборки образов той же винды, который показывают нашим чекистам? Или у них свои, сляпаные из этих исходников, сборки винды? :)
                                                                      Если все бекдоры вырежут, это будет хороший подарок чекистам, так взять и слить бекдоры в стоковой винде. Потому как скомпиленные бинари переводятся в графы исполнения, и если дифф показывает, что вырезана ветка кода или вызов функции, место внимательно изучается.
                                                                        +3
                                                                        Да, гораздо проще оставлять бэкдоры типа

                                                                        if ((options == (__WCLONE|__WALL)) && (current->uid = 0))
                                                                        retval = -EINVAL;

                                                                        Скажете, статический анализатор кода? Так надо писать так, чтобы эта ошибка утонула в тысячах срабатываний!
                                                                    +7
                                                                    Шаг конечно правильный.
                                                                    НО как показывает практика последних лет уязвимость может быть настолько неочевидной, насколько хватит фантазии ее разработчиков.
                                                                    И абсолютно открытый код тут не спасает. И большое количество тестировщиков.
                                                                    А что можно сказать о проверке кода одной фирмой. Ну прогонят на очевидные уязвимости и все?
                                                                      –2
                                                                      С одной стороны, понимают ли в Минкомсвязи, сколько это мегабайт текста?
                                                                      И сколько понадобится человеко-месяцев, чтобы это просто прочитать.
                                                                      С другой стороны, SAP и Apple понимают, что чем дольше исходники будут «на изучении», тем больше шанс их утечки.
                                                                      Поэтому ситуация двоякая — дать — огрести рисков, не дать — огрести рисков :)
                                                                        +1
                                                                        Коды Windows 7, Windows Server 2008 R2, Office 2010, SQL Server 2008 R2, Exchange Server 2010 уже получали: www.winline.ru/news/microsoft_predostavila_fsb_iskhodnyje_kody_windows_7_i_office_2010.php
                                                                          –5
                                                                          говорят что исходники от Microsoft не понимает никто, в том числе сама Microsoft ;) Так что что публикуй, что не публикуй, даже если попадет в открытый доступ — мелкомягким это никак не навредит ;)
                                                                            +7
                                                                            Байки. По сравнению с линуксом просто образец идеального порядка

                                                                            Скрытый текст
                                                                            //
                                                                            // The following macro initializes thread local variables for the wait
                                                                            // for multiple objects kernel service while context switching is disabled.
                                                                            //
                                                                            // N.B. IRQL must be raised to DPC level prior to the invocation of this
                                                                            //      macro.
                                                                            //
                                                                            // N.B. Initialization is done in this manner so this code does not get
                                                                            //      executed inside the dispatcher lock.
                                                                            //
                                                                            
                                                                            #define InitializeWaitMultiple()                                            \
                                                                                Thread->WaitBlockList = WaitBlockArray;                                 \
                                                                                Index = 0;                                                              \
                                                                                do {                                                                    \
                                                                                    WaitBlock = &WaitBlockArray[Index];                                 \
                                                                                    WaitBlock->Object = Object[Index];                                  \
                                                                                    WaitBlock->WaitKey = (CSHORT)(Index);                               \
                                                                                    WaitBlock->WaitType = WaitType;                                     \
                                                                                    WaitBlock->Thread = Thread;                                         \
                                                                                    WaitBlock->NextWaitBlock = &WaitBlockArray[Index + 1];              \
                                                                                    Index += 1;                                                         \
                                                                                } while (Index < Count);                                                \
                                                                                WaitBlock->NextWaitBlock = &WaitBlockArray[0];                          \
                                                                                Thread->WaitStatus = 0;                                                 \
                                                                                if (ARGUMENT_PRESENT(Timeout)) {                                        \
                                                                                    WaitTimer->NextWaitBlock = &WaitBlockArray[0];                      \
                                                                                    KiSetDueTime(Timer, *Timeout, &Hand);                               \
                                                                                    DueTime.QuadPart = Timer->DueTime.QuadPart;                         \
                                                                                    InitializeListHead(&Timer->Header.WaitListHead);                    \
                                                                                }                                                                       \
                                                                                Thread->Alertable = Alertable;                                          \
                                                                                Thread->WaitMode = WaitMode;                                            \
                                                                                Thread->WaitReason = (UCHAR)WaitReason;                                 \
                                                                                Thread->WaitListEntry.Flink = NULL;                                     \
                                                                                StackSwappable = KiIsKernelStackSwappable(WaitMode, Thread);            \
                                                                                Thread->WaitTime = KiQueryLowTickCount()
                                                                            
                                                                            NTSTATUS
                                                                            KeWaitForMultipleObjects (
                                                                                __in ULONG Count,
                                                                                __in_ecount(Count) PVOID Object[],
                                                                                __in WAIT_TYPE WaitType,
                                                                                __in KWAIT_REASON WaitReason,
                                                                                __in KPROCESSOR_MODE WaitMode,
                                                                                __in BOOLEAN Alertable,
                                                                                __in_opt PLARGE_INTEGER Timeout,
                                                                                __out_opt PKWAIT_BLOCK WaitBlockArray
                                                                                )
                                                                            
                                                                            /*++
                                                                            
                                                                            Routine Description:
                                                                            
                                                                                This function waits until the specified objects attain a state of
                                                                                Signaled. The wait can be specified to wait until all of the objects
                                                                                attain a state of Signaled or until one of the objects attains a state
                                                                                of Signaled. An optional timeout can also be specified. If a timeout
                                                                                is not specified, then the wait will not be satisfied until the objects
                                                                                attain a state of Signaled. If a timeout is specified, and the objects
                                                                                have not attained a state of Signaled when the timeout expires, then
                                                                                the wait is automatically satisfied. If an explicit timeout value of
                                                                                zero is specified, then no wait will occur if the wait cannot be satisfied
                                                                                immediately. The wait can also be specified as alertable.
                                                                            
                                                                            Arguments:
                                                                            
                                                                                Count - Supplies a count of the number of objects that are to be waited
                                                                                    on.
                                                                            
                                                                                Object[] - Supplies an array of pointers to dispatcher objects.
                                                                            
                                                                                WaitType - Supplies the type of wait to perform (WaitAll, WaitAny).
                                                                            
                                                                                WaitReason - Supplies the reason for the wait.
                                                                            
                                                                                WaitMode  - Supplies the processor mode in which the wait is to occur.
                                                                            
                                                                                Alertable - Supplies a boolean value that specifies whether the wait is
                                                                                    alertable.
                                                                            
                                                                                Timeout - Supplies a pointer to an optional absolute of relative time over
                                                                                    which the wait is to occur.
                                                                            
                                                                                WaitBlockArray - Supplies an optional pointer to an array of wait blocks
                                                                                    that are to used to describe the wait operation.
                                                                            
                                                                            Return Value:
                                                                            
                                                                                The wait completion status. A value of STATUS_TIMEOUT is returned if a
                                                                                timeout occurred. The index of the object (zero based) in the object
                                                                                pointer array is returned if an object satisfied the wait. A value of
                                                                                STATUS_ALERTED is returned if the wait was aborted to deliver an alert
                                                                                to the current thread. A value of STATUS_USER_APC is returned if the
                                                                                wait was aborted to deliver a user APC to the current thread.
                                                                            
                                                                            --*/
                                                                            
                                                                            {
                                                                            
                                                                                PKPRCB CurrentPrcb;
                                                                                LARGE_INTEGER DueTime;
                                                                                ULONG Hand;
                                                                                ULONG_PTR Index;
                                                                                LARGE_INTEGER NewTime;
                                                                                PKMUTANT Objectx;
                                                                                PLARGE_INTEGER OriginalTime;
                                                                                PRKQUEUE Queue;
                                                                                LOGICAL StackSwappable;
                                                                                PRKTHREAD Thread;
                                                                                PRKTIMER Timer;
                                                                                PRKWAIT_BLOCK WaitBlock;
                                                                                NTSTATUS WaitStatus;
                                                                                PKWAIT_BLOCK WaitTimer;
                                                                            
                                                                                //
                                                                                // Set constant variables.
                                                                                //
                                                                            
                                                                                Hand = 0;
                                                                                Thread = KeGetCurrentThread();
                                                                                OriginalTime = Timeout;
                                                                                Timer = &Thread->Timer;
                                                                                WaitTimer = &Thread->WaitBlock[TIMER_WAIT_BLOCK];
                                                                            
                                                                                //
                                                                                // If a wait block array has been specified, then the maximum number of
                                                                                // objects that can be waited on is specified by MAXIMUM_WAIT_OBJECTS.
                                                                                // Otherwise the builtin wait blocks in the thread object are used and
                                                                                // the maximum number of objects that can be waited on is specified by
                                                                                // THREAD_WAIT_OBJECTS. If the specified number of objects is not within
                                                                                // limits, then bugcheck.
                                                                                //
                                                                            
                                                                                if (ARGUMENT_PRESENT(WaitBlockArray)) {
                                                                                    if (Count > MAXIMUM_WAIT_OBJECTS) {
                                                                                        KeBugCheck(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
                                                                                    }
                                                                            
                                                                                } else {
                                                                                    if (Count > THREAD_WAIT_OBJECTS) {
                                                                                        KeBugCheck(MAXIMUM_WAIT_OBJECTS_EXCEEDED);
                                                                                    }
                                                                            
                                                                                    WaitBlockArray = &Thread->WaitBlock[0];
                                                                                }
                                                                            
                                                                                ASSERT(Count != 0);
                                                                            
                                                                                //
                                                                                // If the dispatcher database is already held, then initialize the thread
                                                                                // local variables. Otherwise, raise IRQL to DPC level, initialize the
                                                                                // thread local variables, and lock the dispatcher database.
                                                                                //
                                                                            
                                                                                if (ReadForWriteAccess(&Thread->WaitNext) == FALSE) {
                                                                                    goto WaitStart;
                                                                                }
                                                                            
                                                                                Thread->WaitNext = FALSE;
                                                                                InitializeWaitMultiple();
                                                                            
                                                                                //
                                                                                // Start of wait loop.
                                                                                //
                                                                                // Note this loop is repeated if a kernel APC is delivered in the middle
                                                                                // of the wait or a kernel APC is pending on the first attempt through
                                                                                // the loop.
                                                                                //
                                                                            
                                                                                do {
                                                                            
                                                                                    //
                                                                                    // Test to determine if a kernel APC is pending.
                                                                                    //
                                                                                    // If a kernel APC is pending, the special APC disable count is zero,
                                                                                    // and the previous IRQL was less than APC_LEVEL, then a kernel APC
                                                                                    // was queued by another processor just after IRQL was raised to
                                                                                    // DISPATCH_LEVEL, but before the dispatcher database was locked.
                                                                                    //
                                                                                    // N.B. This can only happen in a multiprocessor system.
                                                                                    //
                                                                            
                                                                                    Thread->Preempted = FALSE;
                                                                                    if (Thread->ApcState.KernelApcPending &&
                                                                                        (Thread->SpecialApcDisable == 0) &&
                                                                                        (Thread->WaitIrql < APC_LEVEL)) {
                                                                            
                                                                                        //
                                                                                        // Unlock the dispatcher database and lower IRQL to its previous
                                                                                        // value. An APC interrupt will immediately occur which will result
                                                                                        // in the delivery of the kernel APC if possible.
                                                                                        //
                                                                            
                                                                                        KiUnlockDispatcherDatabase(Thread->WaitIrql);
                                                                            
                                                                                    } else {
                                                                            
                                                                                        //
                                                                                        // Construct wait blocks and check to determine if the wait is
                                                                                        // already satisfied. If the wait is satisfied, then perform
                                                                                        // wait completion and return. Else put current thread in a wait
                                                                                        // state if an explicit timeout value of zero is not specified.
                                                                                        //
                                                                            
                                                                                        Index = 0;
                                                                                        if (WaitType == WaitAny) {
                                                                                            do {
                                                                            
                                                                                                //
                                                                                                // Test if wait can be satisfied immediately.
                                                                                                //
                                                                                
                                                                                                Objectx = (PKMUTANT)Object[Index];
                                                                                
                                                                                                ASSERT(Objectx->Header.Type != QueueObject);
                                                                                
                                                                                                //
                                                                                                // If the object is a mutant object and the mutant object
                                                                                                // has been recursively acquired MINLONG times, then raise
                                                                                                // an exception. Otherwise if the signal state of the mutant
                                                                                                // object is greater than zero, or the current thread is
                                                                                                // the owner of the mutant object, then satisfy the wait.
                                                                                                //
                                                                            
                                                                                                if (Objectx->Header.Type == MutantObject) {
                                                                                                    if ((Objectx->Header.SignalState > 0) ||
                                                                                                        (Thread == Objectx->OwnerThread)) {
                                                                                                        if (Objectx->Header.SignalState != MINLONG) {
                                                                                                            KiWaitSatisfyMutant(Objectx, Thread);
                                                                                                            WaitStatus = (NTSTATUS)(Index | Thread->WaitStatus);
                                                                                                            goto NoWait;
                                                                            
                                                                                                        } else {
                                                                                                            KiUnlockDispatcherDatabase(Thread->WaitIrql);
                                                                                                            ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
                                                                                                        }
                                                                                                    }
                                                                            
                                                                                                //
                                                                                                // If the signal state is greater than zero, then satisfy
                                                                                                // the wait.
                                                                                                //
                                                                            
                                                                                                } else if (Objectx->Header.SignalState > 0) {
                                                                                                    KiWaitSatisfyOther(Objectx);
                                                                                                    WaitStatus = (NTSTATUS)(Index);
                                                                                                    goto NoWait;
                                                                                                }
                                                                            
                                                                                                Index += 1;
                                                                            
                                                                                            } while(Index < Count);
                                                                            
                                                                                        } else {
                                                                                            do {
                                                                            
                                                                                                //
                                                                                                // Test if wait can be satisfied.
                                                                                                //
                                                                                
                                                                                                Objectx = (PKMUTANT)Object[Index];
                                                                                
                                                                                                ASSERT(Objectx->Header.Type != QueueObject);
                                                                                
                                                                                                //
                                                                                                // If the object is a mutant object and the mutant object
                                                                                                // has been recursively acquired MINLONG times, then raise
                                                                                                // an exception. Otherwise if the signal state of the mutant
                                                                                                // object is less than or equal to zero and the current
                                                                                                // thread is not the  owner of the mutant object, then the
                                                                                                // wait cannot be satisfied.
                                                                                                //
                                                                            
                                                                                                if (Objectx->Header.Type == MutantObject) {
                                                                                                    if ((Thread == Objectx->OwnerThread) &&
                                                                                                        (Objectx->Header.SignalState == MINLONG)) {
                                                                                                        KiUnlockDispatcherDatabase(Thread->WaitIrql);
                                                                                                        ExRaiseStatus(STATUS_MUTANT_LIMIT_EXCEEDED);
                                                                            
                                                                                                    } else if ((Objectx->Header.SignalState <= 0) &&
                                                                                                              (Thread != Objectx->OwnerThread)) {
                                                                                                        break;
                                                                                                    }
                                                                            
                                                                                                //
                                                                                                // If the signal state is less than or equal to zero, then
                                                                                                // the wait cannot be satisfied.
                                                                                                //
                                                                            
                                                                                                } else if (Objectx->Header.SignalState <= 0) {
                                                                                                    break;
                                                                                                }
                                                                            
                                                                                                Index += 1;
                                                                            
                                                                                            } while(Index < Count);
                                                                            
                                                                                            //
                                                                                            // If all objects have been scanned, then satisfy the wait.
                                                                                            //
                                                                            
                                                                                            if (Index == Count) {
                                                                                                WaitBlock = &WaitBlockArray[0];
                                                                                                do {
                                                                                                    Objectx = (PKMUTANT)WaitBlock->Object;
                                                                                                    KiWaitSatisfyAny(Objectx, Thread);
                                                                                                    WaitBlock = WaitBlock->NextWaitBlock;
                                                                                                } while (WaitBlock != &WaitBlockArray[0]);
                                                                            
                                                                                                WaitStatus = (NTSTATUS)Thread->WaitStatus;
                                                                                                goto NoWait;
                                                                                            }
                                                                                        }
                                                                            
                                                                                        //
                                                                                        // Test for alert pending.
                                                                                        //
                                                                            
                                                                                        TestForAlertPending(Alertable);
                                                                            
                                                                                        //
                                                                                        // Check to determine if a timeout value is specified.
                                                                                        //
                                                                            
                                                                                        if (ARGUMENT_PRESENT(Timeout)) {
                                                                            
                                                                                            //
                                                                                            // Check if the timer has already expired.
                                                                                            //
                                                                                            // N.B. The constant fields of the timer wait block are
                                                                                            //      initialized when the thread is initialized. The
                                                                                            //      constant fields include the wait object, wait key,
                                                                                            //      wait type, and the wait list entry link pointers.
                                                                                            //
                                                                            
                                                                                            if (KiCheckDueTime(Timer) == FALSE) {
                                                                                                WaitStatus = (NTSTATUS)STATUS_TIMEOUT;
                                                                                                goto NoWait;
                                                                                            }
                                                                            
                                                                                            WaitBlock->NextWaitBlock = WaitTimer;
                                                                                        }
                                                                            
                                                                                        //
                                                                                        // Insert wait blocks in object wait lists.
                                                                                        //
                                                                            
                                                                                        WaitBlock = &WaitBlockArray[0];
                                                                                        do {
                                                                                            Objectx = (PKMUTANT)WaitBlock->Object;
                                                                                            InsertTailList(&Objectx->Header.WaitListHead, &WaitBlock->WaitListEntry);
                                                                                            WaitBlock = WaitBlock->NextWaitBlock;
                                                                                        } while (WaitBlock != &WaitBlockArray[0]);
                                                                            
                                                                                        //
                                                                                        // If the current thread is processing a queue entry, then attempt
                                                                                        // to activate another thread that is blocked on the queue object.
                                                                                        //
                                                                            
                                                                                        Queue = Thread->Queue;
                                                                                        if (Queue != NULL) {
                                                                                            KiActivateWaiterQueue(Queue);
                                                                                        }
                                                                            
                                                                                        //
                                                                                        // Set the thread wait parameters, set the thread dispatcher state
                                                                                        // to Waiting, and insert the thread in the wait list.
                                                                                        //
                                                                            
                                                                                        CurrentPrcb = KeGetCurrentPrcb();
                                                                                        Thread->State = Waiting;
                                                                                        if (StackSwappable != FALSE) {
                                                                                            InsertTailList(&CurrentPrcb->WaitListHead, &Thread->WaitListEntry);
                                                                                        }
                                                                            
                                                                                        //
                                                                                        // Set swap busy for the current thread, unlock the dispatcher
                                                                                        // database, and switch to a new thread.
                                                                                        //
                                                                                        // Control is returned at the original IRQL.
                                                                                        //
                                                                            
                                                                                        ASSERT(Thread->WaitIrql <= DISPATCH_LEVEL);
                                                                            
                                                                                        KiSetContextSwapBusy(Thread);
                                                                                        if (ARGUMENT_PRESENT(Timeout)) {
                                                                                            KiInsertOrSignalTimer(Timer, Hand);
                                                                            
                                                                                        } else {
                                                                                            KiUnlockDispatcherDatabaseFromSynchLevel();
                                                                                        }
                                                                            
                                                                                        WaitStatus = (NTSTATUS)KiSwapThread(Thread, CurrentPrcb);
                                                                            
                                                                                        //
                                                                                        // If the thread was not awakened to deliver a kernel mode APC,
                                                                                        // then return the wait status.
                                                                                        //
                                                                            
                                                                                        if (WaitStatus != STATUS_KERNEL_APC) {
                                                                                            return WaitStatus;
                                                                                        }
                                                                            
                                                                                        if (ARGUMENT_PRESENT(Timeout)) {
                                                                            
                                                                                            //
                                                                                            // Reduce the amount of time remaining before timeout occurs.
                                                                                            //
                                                                            
                                                                                            Timeout = KiComputeWaitInterval(OriginalTime,
                                                                                                                            &DueTime,
                                                                                                                            &NewTime);
                                                                                        }
                                                                                    }
                                                                            
                                                                                    //
                                                                                    // Raise IRQL to SYNCH level, initialize the thread local variables,
                                                                                    // and lock the dispatcher database.
                                                                                    //
                                                                            
                                                                            WaitStart:
                                                                                    Thread->WaitIrql = KeRaiseIrqlToSynchLevel();
                                                                                    InitializeWaitMultiple();
                                                                                    KiLockDispatcherDatabaseAtSynchLevel();
                                                                            
                                                                                } while (TRUE);
                                                                            
                                                                                //
                                                                                // The thread is alerted or a user APC should be delivered. Unlock the
                                                                                // dispatcher database, lower IRQL to its previous value, and return
                                                                                // the wait status.
                                                                                //
                                                                            
                                                                                KiUnlockDispatcherDatabase(Thread->WaitIrql);
                                                                                return WaitStatus;
                                                                            
                                                                                //
                                                                                // The wait has been satisfied without actually waiting.
                                                                                //
                                                                                // Unlock the dispatcher database and remain at SYNCH level.
                                                                                //
                                                                            
                                                                            NoWait:
                                                                            
                                                                                KiUnlockDispatcherDatabaseFromSynchLevel();
                                                                            
                                                                                //
                                                                                // Adjust the thread quantum, exit the scheduler, and return the wait
                                                                                // completion status.
                                                                                //
                                                                            
                                                                                KiAdjustQuantumThread(Thread);
                                                                                return WaitStatus;
                                                                            }
                                                                              0
                                                                              Может быть самый красивый отформатированный кусок, на публику? Была же как-то статья от анонимного разработчика, который рассказывал, как там у них всё устроено на самом деле.
                                                                                +1
                                                                                Я смотрел исходники XP по программе Windows Research Core. Лицензией там явно указан запрет на публикацию каких-либо частей. Но могу сказать, что на мой, студенческий тогда, взгляд там все было понятно.

                                                                                Стиль местами немного разный. Местами комменты для магической константы в виде // magic number, местами построчно и с ASCII-графикой расписанный алгоритм балансировки дерева (с припиской, что Кнут говорит, что это просто)
                                                                        +1
                                                                        А если они предоставят не весь код, а только его безопасную для российских пользователей часть — типа всё чисто, всё работает
                                                                          +1
                                                                          Грамотно просить Code Base — полную настройку инструментария и начальные данные с которыми на глазах собирается продукт.
                                                                            –2
                                                                            Продукт можно собрать «для вида» используя безопасный код, а вот для пользователей компилировать уже, добавив код перехвата данных и прочее
                                                                              +5
                                                                              Вот именно. Как только MD5 бинарников перестанет совпадать, можно точно знать что именно в конечной поставке собрали «особенным образом».

                                                                              Хотя постоянные патчи… Вот дыра всем дырам дыра — при обновлении проверенно чистого продукта можно вкатить сколько угодно запасных дверей.

                                                                              Тем и хорош опенсорец, что и обновления можно контролировать. Или «государственная» ось — и внедрять только прочитанные патчи.
                                                                                +1
                                                                                Другая версия компилятора / другие флаги компиляции, да и просто хотя бы другая система, на которой собиралось, дадут не идентичные бинарники.
                                                                                  0
                                                                                  Code base ВКЛЮЧАЕТ компиляторы, их настройки и многое другое. Codebase учитывает всё.
                                                                                  0
                                                                                  Как нам рассказывали на ИБ, при установки сертифицированной винды сервера обновлений находятся во ФСТЭК.
                                                                                    0
                                                                                    Вы хотите сказать, что ФСТЭК пишет патчи?
                                                                                      0
                                                                                      Мне говорили, что апдейты проходят через их сервис. Они едва ли пишут патчи, разве что на фсбшные закладки
                                                                            +12
                                                                            Ребята в комментариях выше, полагающие, что кто-то проверял исходники, например, винды, очень и очень наивны.

                                                                            Во-первых, Вы хотя бы можете представить объект исходного кода, который требуется проверять? Википедия говорит, что в WindowsXP было 45 млн строк кода, что в 2 с копейками раз больше, чем в Windows 2000. Да и потом, давно утекала Windows 2000 — это мало кому помогло, только отдельные хаки и специфичные вещи оттуда удалось вытащить высококвалифицированным специалистам. Из тех людей, с кем я знаком в проверяющие органах, таковых нет.

                                                                            Во-вторых, я эту сертифицированную винду седьмую видел (во сне, конечно, где я ее вживую увижу?). Просто винда, в который выпилены почти все драйвера. С таким же успехом можно назвать какую-нибудь некогда популярную сборку ZverCD — сертифицированной виндой.

                                                                            Я сюжет вижу приблизительно так:
                                                                            с виндой многим удобнее работать, потому что все привыкли, есть софт, вот это всё. Принести какой-то левый код (библиотеку boots, скажем) вперемежку с оригинальным кодом (калькулятора какого-нибудь), назвали это кодом винду, «проверили», «сертифицировали» и пустили на продажу. И волки сыты, и овцы целы.
                                                                            • UFO just landed and posted this here
                                                                                +1
                                                                                Во первых зачем собирать, во вторых, вы проверяли? :)
                                                                                  –1
                                                                                  Кудазачем?! Попкорну побольше!

                                                                                  Хотя, меж нами говоря, уже наличие никем не перелистанной распечатки исходников в застенках и подвалах уполномоченных органов является юридическим поводом для внедрения софта в государство. Никто и не будет читать, дело только в ритуале распечатки в подвал, буде там хоть «Си по белому» коды троянцев.
                                                                                  +3
                                                                                  реквестирую исходные коды OS X и iOS на гитхаб
                                                                                  +8
                                                                                  А ему не приходило в голову, что уязвимость может добавить компилятор? :-) А если так, то может ему еще и исходники компилятора показать? Ой, а их ведь тоже чем-то компилировать нужно! Shit, так и придется искать уязвимости в бинарном или asm коде! А какая клевая была идея…
                                                                                    –6
                                                                                    Не раз бывало когда личные данные, размещенные на сайтах госуслуг индексировали поисковые роботы.
                                                                                    Не будет ли такого с исходными кодами коммерческих продуктов?
                                                                                      –3
                                                                                      Их проиндексируют на горбушке
                                                                                      +3
                                                                                      Атлас — ФСБ-шная контора, так что неудивительно. Помню, как меня бухи послали за сертификатами Такскома в Управление ФСБ, там охранники смотрели на меня как на говорящего буратину (контора перехала к тому моменту).
                                                                                        0
                                                                                        пардон, не туда написал…
                                                                                        +1
                                                                                        Судя по их зарплатам там адекватных спецов нет. Да и как они собираются искать «недекларированный функционал»? Пальчиком по коду водить будут?
                                                                                        Чтобы иметь инструментарий выявления подобных вещей, надо было вкладывать деньги в исследования и развитие подобного инструментария не год и не два…

                                                                                        Так что за то, что найдут закладки SAP и Apple могут не переживать. Но они должны быть готовы, что код утечёт…
                                                                                          –2
                                                                                          И это правильно! Какие там американские санкции… какое там китайское пиратство…
                                                                                          Русские всегда просят по-хорошему… иначе БУДЕТ ПО-ПЛОХОМУ!!!

                                                                                          Only users with full accounts can post comments. Log in, please.