[Закрываются] любимые (умные) лучшие практики безопасного программирования

• Крошечные понятные классы. Многие из них.
• Крошечные понятные Методы.
• Неизменный по мере возможности.
• Минимизируют объем - ничто общедоступное, которое может быть пакетом, ничто пакет, который может быть частным.
• никогда любое оправдание за общедоступную изменяемую переменную.

кроме того, то, когда Ваши классы являются крошечными и обычно окончательными, будучи защитными, действительно дешево - мог бы также добавить его независимо от того, если Вы верите в него или нет. Протестируйте значения, передаваемые Вашим конструкторам и (если у Вас действительно ДОЛЖНЫ быть они), методы set.

В Perl умрите (), когда подпрограммы не будут переданы достаточно параметров. Это препятствует тому, чтобы Вы получили отказы, что необходимо проследить 10 уровней через стек.

sub foo {
    my $param0 = shift or confess "param0 is a required param";
    my $param1 = shift or confess "param1 is a required param";
    my $param2 = shift or confess "param2 is a required param";
    ...
}

Разработайте свою стратегию входа так, чтобы то, когда ошибка происходит в производстве, соответствующем представителе технической поддержки или разработчике, было послано по электронной почте автоматически. Это позволяет Вам заранее находить ошибки, вместо того, чтобы ожидать пользователей для жалобы.

Примечание, что это должно быть сделано с некоторой осторожностью. Один пример, который я имел, был то, что разработчик написал некоторый регистрирующийся код в цикле. После нескольких месяцев ошибка в системе инициировала этот код. К сожалению, приложение находилось в том цикле, регистрируя ту же ошибку много раз. Мы прибыли в офис тем утром, чтобы быть информированными, что наш почтовый сервер отказал после того, как наша платформа журналирования послала 40 000 электронных писем между часами 4:00 и 8:00!

Попытайтесь не создать что-либо, что Вы разрабатываете в течение нескольких недель. Часто другие сценарии будут прибывать к Вам затем, прежде чем вещи будут привязаны.

Назад к тем дням, где RAM не была свободна, большинство компьютеров было очень ограничено и "НЕДОСТАТОЧНО ПАМЯТИ!" было сообщение довольно распространенной ошибки...

ну, большая часть приложения затем смогла отказать с 'элегантностью': пользователи (почти) никогда не теряли свои работы.

(Почти, я сказал! ^^).

, Как это было сделано? Очень простой: когда Вы, которых запускает приложение, выделяют воздушный шар RAM (скажите, огромные 20 КБ!). Затем когда вызов к malloc () сбои:

1. Говорят любезно, что существует "НЕДОСТАТОЧНО ПАМЯТИ" (это сообщение было обязательно).
2. Добавляют, "И Вы лучше сохраняете всю свою работу. Теперь!"
3. Выпуск огромный воздушный шар на 20 КБ RAM.
4. Резюме.

И voilГ. Ваше приложение отказывает медленно в пользователе, большую часть времени, может сохранить, это - работа.

• Делают Ваш код максимально читаемым, особенно при помощи имен функций и имен переменной, которые максимально очевидны. Если это означает, что некоторые имена находятся немного на длинной стороне, то пусть будет так.

• Использование статический анализатор как можно больше. Вы скоро вырабатываете привычку написания кода, которое соответствует его правилам.

• Во время разработки, помогите включить диагностический вывод - но помочь выключить их для производства.

При выполнении многопоточного программирования C/C++ создайте серию макросов, которые утверждают, что функция вызывается на потоке, Вы думаете то, что это было обращенным. Тогда используйте их подробно.

• ASSERT_ON_UI_THREAD
• ASSERT_ON_WORKER_THREAD
• ASSERT_ON_THREADPOOL_THREAD
• ASSERT_ON_DOWNLOAD _THREAD
• и т.д.

Использование GetCurrentThreadId () в Windows или pthread_self () на Posix, когда поток будет инициализирован, затем сохраните в globals. Утверждение выдерживает сравнение с хранимой суммой.

сохранил меня большая болезненная отладка, особенно когда кто-то еще осуществляет рефакторинг существующий многопоточный код.

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

А хорошая параллель имела бы общедоступную переменную вместо метода set/метода get. метод set/метод get позволяет Вам изменять свою конкретную реализацию, не производя внешний мир.

, Как Вы изменяете свою структуру данных, не производя внешний мир, если Вы раздаете набор? Весь доступ для Вашего набора распределяется всюду по всему Вашему коду!!

Вместо этого обертка это и дают себе место для помещения небольшой бизнес-логики. Вы найдете, что некоторые хорошие осуществляют рефакторинг, как только Вы сделали так.

Часто Вы будете находить, что имеет смысл добавлять некоторые переменные и возможно второй набор - тогда Вы поймете, что этот класс отсутствовал все время!

If (some really bad condition) Then
Throw New Exception("particular bad thing happened")
End If


Обычно это принимает форму

Общедоступный Новый SUb (ключ Как Гуид)
Тусклый oReturn Как returnpacket = Сервисы. TableBackedObjectServices. GetData (ключ)
, Если oReturn.ds.tables (0).Rows. Количество = 0 затем Выдает Новое Исключение ("TableBackedObject, загруженный из ключа, не был найден в базе данных".)
Конец, Если

С тех пор, которым конкретного конструктора, как только предполагается, вызывают при загрузке конкретного объекта после выбора его от результатов поисковой процедуры, не находя его, или ошибка или состояние состязания (то, которое означало бы другого пользователя, удалило объект ключом).

В C++

я распространился, утверждает на всем протяжении моих функций, особенно в запуске и конце функций для ловли любого неожиданного ввода/вывода. Когда я позже добавлю больше функциональности в функции, утверждение поможет мне помнить. Это также помогает другим людям видеть намерение функции и только активно в режиме отладки.

я избегаю указателей как можно больше и вместо этого использую ссылки, тот способ, которым я не должен помещать создание помех if (NULL!=p) - операторы в моем коде.

я также использую Word const так часто, как я могу и в объявлениях и как функция/аргументы метода.

я также избегаю использования ПЕРЕХОДНЫХ ПРИСТАВОК и вместо этого использую STL/повышение как можно больше для предотвращения утечек мадам и других противных вещей. Однако я действительно избегаю использования слишком много пользовательские определенные шаблоны, поскольку я нахожу, что они трудно отлаживают, специально для других, которые не написали код.

Используйте консоль, как в играх;

Не абсолютно "защитный", но я получил это от наблюдения его в большом количестве игр.

мне нравится иметь полную консоль для всех моих приложений, которые позволяют мне:

1. Определяют простые команды, которые будут вызваны от консоли (как переключение на режим отладки, устанавливая некоторые динамические переменные, проверьте внутренние параметры конфигурации и так далее).
2. Получают доступ к журналу каждый раз, я хочу от приложения, в то время как приложение работает.
3. Сохраняют журнал в файл в случае необходимости
4. Журнал каждое необработанное исключение к консоли прежде, чем повысить его до пользователя (если appropiate). Тем путем каждое исключение поймано как некоторый уровень. При объединении этого умно с отладочной информацией или файлом карты, можно получить превосходные результаты.

В C#, если Вы отмечаете Консольные методы с Условным Атрибутом затем, они будут автоматически разделены от версии выпуска. На других языках то же может быть достигнуто через директивы препроцессору.

я нашел, что это специально ценно во время фазы тестирования, поскольку это позволяет разработчику видеть то, что происходит и тестер, чтобы предоставить лучшую обратную связь разработчику.

, Кроме того:

• Никогда не ловят исключение только для входа.
• Никогда не ловят общие исключения (исключение E)
• Никогда не скрывают исключения
• предупреждения компилятора Обработки, как будто они были ошибками, только принимают предупреждение с очень тщательным исследованием.
• Всегда проверяют каждый вход, приходящий не из библиотеки.
• Проверка вход, прибывающий из библиотеки в "отладку", не регистрируйтесь в выпуске.
• Никогда не повышают универсальное исключение. Если исключение существует, которые описывают проблему, используют его, если не делают, создайте свое собственное.

Включайте высокоуровневую обработку исключений, как описано подробно здесь

Обработка исключений Верхнего уровня в Приложениях Windows Forms

, Мой Program.cs был бы затем похож на это

    static class Program
    {
    [STAThread]
    static void Main()
    {
        Application.ThreadException += 
            new ThreadExceptionEventHandler(new ThreadExceptionHandler().ApplicationThreadException);

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new MainForm());
    }

    public class ThreadExceptionHandler
    {
        public void ApplicationThreadException(object sender, ThreadExceptionEventArgs e)
        {
            MessageBox.Show(e.Exception.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }
}

Некоторые вещи, которые я делаю в PHP (где ошибки являются легкими и часто катастрофическими):

• Включают все сигналы подсветки синтаксиса в Vim. Существует много выключен по умолчанию (сделайте :help php для наблюдения их). Я думаю о добавлении нескольких выделяющих ошибку моих собственных вещей...
• Используя предварительную фиксацию сцепляются в мерзавце с проверкой синтаксиса (php -l) каждый измененный файл. Это только предотвращает основные ошибки при входе, но это лучше чем ничего.
• обертки Записи вокруг классов базы данных для создания параметризованных подготовленных операторов до полусмерти легкими по сравнению с выводом нормальных запросов - $db->q1($sql, $param1, $param2) для выборки отдельного столбца первой строки, и так далее.
• Конфигурирование его (через расширение Xdebug) для выкладывания гигантских HTML-таблиц информации об отладке даже для тривиальных предупреждающих сообщений, таким образом, невозможно проигнорировать их. На dev сервере, который является. На производстве они тихо зарегистрированы вместо этого.
• вещи Создания, короткие, простые и очевидные. Я трачу партия из времени, просто осуществляющего рефакторинг материал ради создания меньших файлов.
• Используя явный синтаксис управляющей структуры , чтобы не иметь несколько "} "s в непосредственной близости.
• код Корректуры, прежде чем в этом зарегистрируются. Я вошел в привычку к увеличению окна, затем установив нелепо большой размер шрифта. Если я могу только понять его, когда я вижу 132C x 50R на экране сразу в крошечном шрифте, это слишком длинно для начала.

В C#: Вместо этого:

if( str==null )

Делают это:

if( String.IsNullOrEmpty(str) )

C++:

Избегают необработанных указателей, всегда используют пакет интеллектуального указателя Повышения (например, shared_ptr).

Я делаю много математики в моей работе, тестирующей смешанные полупроводники сигнала на Оборудовании автоматического тестирования от Teradyne (c, vba), Advantest (C++ .NET), и т.п..

Два защитных маневра, которые я использую:

• предотвращают деление на нуль, если (x! =0) {z=y/x;} еще {/* дают z распознаваемое поддельное число, продолжаются, программа */}

• не передают нулевые или отрицательные числа для входа вычислений. Это характерно для вычислений усиления, CMRR и PSRR. если (x> 0) {psrr = 20 * журнал (x);} еще {psrr =-999; число/*fake */}

Некоторые могут привести доводы против использования поддельных чисел, но эти программы используются в полупроводниковом производстве очень большого объема. Если ошибка происходит при тестировании плохой части, лучше продолжить тестировать и сохранять целостность формата данных. Поддельные числа легко разделяются как выбросы во время последующей обработки данных тестирования.

- микрофон

Не используйте односимвольные переменные для индексов цикла. Например:

for (int ii = 0 ; ii < someValue ; ii++)
    // loop body

Это - простая привычка, но очень полезно, если необходимо использовать стандартный текстовый редактор для ссылок находки на переменную цикла. Конечно, индексируемые циклы обычно не должны быть такими длинными, что необходимо искать ссылки на указатель...

JavaScript:

Мы должны использовать "==" и "===" соответственно.

==: преобразовывающее тип сравнение равенства

===: строгое сравнение равенства

, Например, '1' == 1 верно, но '1' === 1 является ложью.

Многие люди используют "==" вместо "===" подсознательно.

программное обеспечение Crash-Only , короче говоря вместо того, чтобы требовать некоторой процедуры завершения работы наряду с некоторым используемым seldomly (и следовательно вероятно, багги) код восстановления, всегда останавливают программу путем "катастрофического отказа его" и таким образом всегда выполняют код восстановления при запуске.

Это не применимо ко всему, но в некоторых случаях это - очень отличная идея.

Если существует тип значения, который имеет определенные ограничения на его значение, сделайте класс, где те ограничения осуществляются кодом. Некоторые примеры:

public class SanitizedHtmlString
{
private string val;

public SanitizedHtmlString(string val)
{
  this.val = Sanitize(val);
}

public string Val
{
  get { return val; }
}

//TODO write Sanitize method...
}


public class CarSpeed
{
private int speedInMilesPerHour; 

public CarSpeed(int speedInMilesPerHour)
{
  if (speedInMilesPerHour > 1000 || speedInMilesPerHour < 0)
  {
    throw new ArgumentException("Invalid speed.");
  }
  this.speedInMilesPerHour = speedInMilesPerHour; 
}

public int SpeedInMilesPerHour
{
  get { return speedInMilesPerHour; }
}
}

В Python, если я гашу (или изменяют метод) и затем не имеют времени для тестирования его в тот день, я переполняю в, "утверждают Ложь" так, чтобы код отказал, если метод будет выполнен, то создавая смущающие ошибки я замечу на следующий день. Намеренная синтаксическая ошибка может быть полезной также.

Пример:

def somefunction(*args,**kwargs):
    ''' <description of function and args> '''
    # finish this in the morning
    assert False, "Gregg finish this up"

Для C++: автоматически обнаруживающий размер массивов

char* mystrings[] = { "abc", "xyz" , "pqr" }

обычно затем для записан как

for (int i=0; i< 3; i++)
{
    str= mystrings[i]
    // somecode
}

Однако Позже, можно добавить новый больше строк к' mystrings'. В этом случае, для цикла выше может представить тонкие ошибки в коде.

решение, которое я использую,

int mystringsize = sizeof(mystrings)/sizeof(char*)
for (int i=0; i< mystringsize; i++)
{
    str= mystrings[i]
    // somecode
}

Теперь, если Вы добавляете больше строк к' mystrings' массив, поскольку цикл будет автоматически скорректирован.

В C# используйте 'использование', чтобы удостовериться, что объект расположен, когда это выходит из объема. т.е.

        using(IDataReader results = DbManager.ExecuteQuery(dbCommand, transaction))
        {
            while (results.Read())
            {
                //do something
            }
        }

кроме того, проверьте на нулевые значения после кастинга

        MyObject obj = this.bindingSource.Current as MyObject;
        if (MyObject != null)
        {
           // do something
        }

кроме того, я использую перечисления, когда это возможно, чтобы избежать жесткого кодирования, опечаток и обеспечить легкое переименование при необходимости, т.е.

    private enum MyTableColumns
{ 
    UserID,
    UserName
}

private enum StoredProcedures
{
    usp_getMyUser,
    usp_doSomething
}

public static MyUser GetMyUser(int userID)
{
    List<SqlParameter> spParameters = new List<SqlParameter>();

    spParameters.Add(new SqlParameter(MyTableColumns.UserID.ToString(), userID));


    return MyDB.GetEntity(StoredProcedures.usp_getMyUser.ToString(), spParameters, CommandType.StoredProcedure);
}

Мои инструкции C++, но я не полагаю, что это умно:

• Всегда линт, heck, сделайте это частью Вашего make-файла. Еще лучше используйте coverity, если это возможно.
• не используют исключения C++.
• не помещают слишком много материала на конструктора C++. Используйте init () метод вместо этого. Единственными способами сигнализировать об ошибке в конструкторе являются исключения, который является ЛАВАШЕМ.
• не перегружают оператор, если это не необходимо.
• , Если у Вашего конструктора есть один аргумент, всегда используйте явное ключевое слово.
• Избегают глобальных объектов. Их порядок выполнения не гарантируется.
• Определяют конструктора копии, когда Ваш класс выделяет память. Но если Вы не ожидаете, что класс будет скопирован, и Вы слишком ленивы, чтобы определить один, охранять его от того, чтобы быть названным.

class NonCopied {
private:
    NonCopied(const NonCopied&);
    NonCopied& operator=(const NonCopied&);
}

• Остановка с помощью sprintf (), strcpy (), strcat (). Используйте их замену вместо этого, например, snprintf, strncpy (), и т.д.

при получении таблицы от набора данных

if(  ds != null &&
     ds.tables != null &&
     dt.tables.Count > 0 &&
     ds.tables[0] != null &&
     ds.tables[0].Rows > 0 )
{

    //use the row;
}

В C++ assert() очень удобный инструмент. Я не только предоставляю ему условие оценить, но также и сообщение, указывающее что случилось:

assert( isConditionValid && "ABC might have failed because XYZ is wrong." );

, Когда нет никакой фактической переменной для проверки или Вы оказываетесь в ситуации, которая никогда не должна была происходить (обработчик 'по умолчанию' переключателя ()), это работает также:

assert( 0 && "Invalid parameter" );

Это не только утверждает в режиме отладки, но также и говорит Вам, что пошло не так, как надо одновременно.

я получил это из "Стандартов Кодирования C++", если я помню правильно.

Используйте классы сигнальной метки с определенными основанными на интерфейсе шаблонами ООП вместо null.

, Например, при использовании чего-то как [1 110]

public interface IFileReader {
  List<Record> Read(string file);
}

используют класс сигнальной метки как [1 111]

public class NoReader : IFileReader {
  List<Record> Read(string file) {
    // Depending on your functional requirements in this case
    // you will use one or more of any of the following:
    // - log to your debug window, and/or
    // - throw meaningful exception, and/or
    return new List<Record>(); // - graceful fall back, and/or
    // - whatever makes sense to you here...
  }
}

и используют его для инициализации любой переменной IFileReader

IFileReader reader = new NoReader();

вместо того, чтобы просто оставить их null (или неявно или явно)

IFileReader reader; /* or */
IFileReader reader = null;

, чтобы удостовериться, что Вы не получаете неожиданные исключения нулевого указателя.

Премия: Вы не должны действительно монтировать в корпус каждый IFileReader переменное использование с if (var!=null) ... больше также, потому что они не будут null.

В c# использовании TryParse вместо Синтаксический анализ , чтобы типы значения избежали исключений как FormatException, OverflowException и т.д., конечно, чтобы не писать блок попытки для того же.

Плохой код

string numberText = "123"; // or any other invalid value

public int GetNumber(string numberText)
  {
  try
  {
     int myInt = int.Parse(numberText);
     return myInt;
  }
  catch (FormatException)
  {
    //log the error if required
     return 0;
   }
  catch (OverflowException)
  {
     return 0;
  }
}

Хороший код (если Вы не хотите обрабатывать ошибки)

string numberText = "123"; // or any other invalid value
public int GetNumber(string numberText, int defaultReturnValue)
  {
    int myInt;
    return ( int.TryParse(numberText, out myInt) ) ?  myInt : defaultReturnValue;
}

можно сделать то же почти для всех типов значения, например: булевская переменная. TryParse, Int16. TryParse, десятичное число. TryParse и т.д.

Скорее затем var.equals ("вообще") в Java я делаю "любой" .equals (var). Тот путь, если var является пустым, я не должен волноваться о nullpointer исключении. Это работает отлично при контакте с вещами как параметры URL, и т.д.

• При выполнении SQL-запросов от кода, всегда используйте заполнителей
• , MySQL имеет полезное нестандартное расширение DELETE оператор: DELETE FROM sometable WHERE name IS LIKE 'foo%' LIMIT 1. Таким образом, Вы не вытрете целую таблицу в случае ошибки.