Strategia utrzymywania tajnych informacji, takich jak klucze API poza kontrolą źródła?

Pracuję nad witryną, która pozwoli użytkownikom zalogować się przy użyciu poświadczeń OAuth takich jak Twitter, Google itp. Aby to zrobić, muszę się zarejestrować u różnych dostawców i uzyskać super tajny klucz API, który mam w celu zabezpieczenia przyrzeczeniami przeciw różnym częściom ciała. Jeśli mój klucz zostanie zasadzony, część zostanie wyrwana.

Klucz API musi podróżować z moim źródłem, ponieważ jest używany w czasie wykonywania do wykonywania żądań uwierzytelnienia. W moim przypadku klucz musi istnieć w aplikacji w pliku konfiguracyjnym lub w samym kodzie. Nie stanowi to problemu, gdy buduję i publikuję z jednego komputera. Jednak kiedy wrzucamy kontrolę źródła do miksu, sprawy stają się bardziej skomplikowane.

Ponieważ jestem tanim dranem, wolałbym korzystać z bezpłatnych usług kontroli źródła, takich jak TFS w chmurze lub GitHub. To pozostawia mi lekką zagadkę:

Jak mogę zachować moje ciało nienaruszone, gdy moje klucze API znajdują się w moim kodzie, a mój kod jest dostępny w publicznym repozytorium?

Mogę wymyślić wiele sposobów, aby sobie z tym poradzić, ale żaden z nich nie jest tak satysfakcjonujący.

• Mogę usunąć wszystkie prywatne informacje z kodu i edytować je ponownie po wdrożeniu. Byłby to poważny ból do wdrożenia (nie będę szczegółowo opisywać wielu sposobów) i nie jest opcją.
• Mógłbym to zaszyfrować. Ale ponieważ muszę go odszyfrować, każdy ze źródłem może wymyślić, jak to zrobić. Bezcelowy.
• Mógłbym zapłacić za prywatną kontrolę źródła. LOL j / k wydawać pieniądze? Proszę.
• Mógłbym użyć funkcji językowych, aby oddzielić wrażliwe informacje od reszty mojego źródła, a tym samym uniemożliwić kontrolę źródła. To właśnie robię teraz, ale można to łatwo zepsuć, błędnie sprawdzając tajny plik.

Naprawdę szukam gwarantowanego sposobu, aby upewnić się, że nie podzielę się swoimi prywatnymi osobami ze światem (z wyjątkiem Snapchata), który będzie działał płynnie poprzez programowanie, debugowanie i wdrażanie, a także będzie niezawodny. To jest całkowicie nierealne. Co więc realistycznie mogę zrobić?

_{Szczegóły techniczne: VS2012, C # 4.5, kontrola źródła będzie usługą TF lub GitHub. Obecnie używamy częściowej klasy do podziału wrażliwych kluczy w osobnym pliku .cs, który nie zostanie dodany do kontroli źródła. Myślę, że GitHub może mieć tę zaletę, że .gitignore może być użyty do zapewnienia, że ​​plik klasy częściowej nie jest rejestrowany, ale wcześniej to spieprzyłem. Mam nadzieję na „och, wspólny problem, oto jak to robisz”, ale być może będę musiał zadowolić się tym, „że nie jest do bani tak bardzo, jak mogłoby to mieć”,: /}

Nie umieszczaj swoich tajnych informacji w kodzie. Umieść go w pliku konfiguracyjnym, który jest odczytywany przez kod podczas uruchamiania. Pliki konfiguracyjne nie powinny być poddawane kontroli wersji, chyba że są „domyślnymi ustawieniami fabrycznymi”, a następnie nie powinny zawierać żadnych prywatnych informacji.

Zobacz także pytanie Kontrola wersji i osobisty plik konfiguracyjny, aby dowiedzieć się, jak to zrobić dobrze.

Możesz umieścić wszystkie klucze prywatne / chronione jako systemowe zmienne środowiskowe. Twój plik konfiguracyjny będzie wyglądał następująco:

private.key=#{systemEnvironment['PRIVATE_KEY']}

W ten sposób radzimy sobie z tymi przypadkami i nic nie wchodzi w kod. Działa bardzo dobrze w połączeniu z różnymi plikami właściwości i profilami. Używamy różnych plików właściwości dla różnych środowisk. W naszym lokalnym środowisku programistycznym umieszczamy klucze programistyczne w plikach właściwości, aby uprościć lokalną konfigurację:

private.key=A_DEVELOPMENT_LONG_KEY

Sposób Pure Git

• .gitignore dołączony plik z prywatnymi danymi
• Użyj lokalnego oddziału, w którym wymienić TEMPLATEzDATA
• Użyj filtrów rozmazywania / czyszczenia, w których skrypt (lokalny) filtra wykonuje dwukierunkową zamianę TEMPLATE<->DATA

Rtęciowy sposób

• Łatki MQ na szczycie fałszywego kodu, które zastępują TEMPLATEsię DATA(zestawy zmian są publiczne, łatka jest prywatna)
• Rozszerzenie słowa kluczowego o specjalnie zaprojektowane słowa kluczowe (rozwinięte tylko w katalogu roboczym )

Metoda agnostyczna SCM

• Zamień słowa kluczowe w ramach procesu kompilacji / wdrażania

Wkładam sekrety do zaszyfrowanych plików, które następnie popełniam. Hasło jest podawane podczas uruchamiania systemu lub jest przechowywane w małym pliku, którego nie zatwierdzam. Fajnie, że Emacs z radością zarządza tymi zaszyfrowanymi plikami. Na przykład plik inicjujący emacsa zawiera: (ładuje „secrets.el.gpg”), co po prostu działa - monitując mnie o hasło w tych rzadkich przypadkach, gdy uruchamiam edytor. Nie martwię się o to, że ktoś złamie szyfrowanie.

Jest to bardzo specyficzne dla Androida / Gradle, ale możesz zdefiniować klucze w gradle.propertiespliku globalnym znajdującym się w user home/.gradle/. Jest to również przydatne, ponieważ można używać różnych właściwości w zależności od buildType lub smaku, tj. API dla deweloperów i różnych dla wydania.

gradle.properties

MY_PRIVATE_API_KEY=12356abcefg

build.gradle

buildTypes {
        debug{
            buildConfigField("String", "GOOGLE_VERIFICATION_API_KEY", "\"" + MY_PRIVATE_API_KEY +"\"")
            minifyEnabled false
            applicationIdSuffix ".debug"
            }
        }

W kodzie będziesz się tak odwoływał

String myAPI = BuildConfig.GOOGLE_VERIFICATION_API_KEY;

Nie należy rozpowszechniać tego klucza w aplikacji ani przechowywać go w repozytorium kodu źródłowego. To pytanie dotyczy tego, jak to zrobić, i nie jest to zwykle wykonywane.

Mobilna aplikacja internetowa

W przypadku systemu Android / iPhone urządzenie powinno poprosić o KLUCZ z własnego serwisu internetowego przy pierwszym uruchomieniu aplikacji. Klucz jest następnie przechowywany w bezpiecznym miejscu. Jeśli klucz zostanie zmieniony lub odwołany przez wydawcę. Twój serwis internetowy może opublikować nowy klucz.

Hostowana aplikacja internetowa

Klienci korzystający z licencji na oprogramowanie będą musieli ręcznie wprowadzić klucz przy pierwszej konfiguracji oprogramowania. Możesz dać każdemu ten sam klucz, inny klucz lub otrzymać własny.

Opublikowano kod źródłowy

Przechowujesz swój kod źródłowy w publicznym repozytorium, ale nie KLUCZ. W konfiguracji pliku dodajesz linie * umieść tutaj klucz * . Gdy programista używa kodu źródłowego, tworzy kopię sample.cfgpliku i dodaje własny klucz.

Nie przechowujesz config.cfgpliku w repozytorium w celu programowania lub produkcji.

Użyj zmiennych środowiskowych do tajnych rzeczy, które zmieniają się dla każdego serwera.

http://en.wikipedia.org/wiki/Environment_variable

Sposób ich użycia zależy od języka.

Myślę, że jest to problem, z którym wszyscy mieli kiedyś problemy.

Oto przepływ pracy, który wykorzystałem, który może działać dla Ciebie. Używa .gitignore z niespodzianką:

1. Wszystkie pliki konfiguracyjne znajdują się w specjalnym folderze (z przykładowymi plikami konfiguracyjnymi - opcjonalnie)
2. Wszystkie pliki konfiguracyjne są zawarte w .gitignore, aby nie były publiczne
3. Skonfiguruj serwer gitolite (lub ulubiony serwer git) na prywatnym urządzeniu
4. Dodaj repozytorium ze wszystkimi plikami konfiguracyjnymi na prywatnym serwerze
5. Dodaj skrypt, aby skopiować pliki konfiguracyjne do specjalnego folderu w głównym repozytorium (opcjonalnie)

Teraz możesz sklonować repozytorium konfiguracji do dowolnego systemu programowania i wdrażania. Wystarczy uruchomić skrypt, aby skopiować pliki do odpowiedniego folderu i gotowe.

Nadal dostajesz wszystkie cukierki GitHub, dzielisz się swoim kodem ze światem, a wrażliwe dane nigdy nie są w głównym repozytorium, więc nie są upubliczniane. Nadal są tylko wyciągnięciem i kopią z dowolnego systemu wdrażania.

Używam skrzynki 15 $ / rok dla prywatnego serwera git, ale możesz też skonfigurować jeden w domu, zgodnie z wymaganiami Cheapskate ;-)

PS: Możesz również użyć submodułu git ( http://git-scm.com/docs/git-submodule ), ale zawsze zapominam o poleceniach, więc szybkie i brudne reguły!

Użyj szyfrowania, ale podczas uruchamiania podaj klucz główny jako hasło w konsoli, w pliku, który tylko użytkownik procesu może odczytać, lub z magazynu kluczy dostarczonego przez system, takiego jak pęku kluczy systemu Mac OS lub magazynu kluczy systemu Windows.

W celu ciągłej dostawy potrzebne są gdzieś zapisane różne klucze. Konfiguracja powinna być oddzielona od kodu, ale sensowne jest utrzymywanie jej pod kontrolą wersji.

3 strategie, o których jeszcze nie wspomniano (?)

Przy odprawie lub w haku VCS do kontroli wstępnej

• szukaj ciągów o wysokiej entropii, na przykład wykrywaj sekrety
• Wyszukaj wyrażenia regularne dla dobrze znanych wzorców kluczy API. Klucze AKIA * AWS są przykładem, git-secrets to jedno narzędzie oparte na tym. Ponadto nazwy zmiennych, takie jak „hasło” ze stałym przypisywaniem.
• szukaj znanych sekretów - znasz swoje sekrety, szukaj ich tekstu. Lub użyj narzędzia, napisałem ten dowód koncepcji .

Strategie już wspomniane

• przechowywać w pliku poza drzewem źródłowym
• mieć je w drzewie źródłowym, ale powiedz VCS, aby je zignorowało
• zmienne środowiskowe są odmianą przechowywania danych poza drzewem źródłowym
• po prostu nie daj cennych tajemnic deweloperom

Trzymaj prywatne informacje poza kontrolą źródła. Utwórz nieobciążone domyślne ustawienie dla dystrybucji i niech twój VCS zignoruje prawdziwy. Twój proces instalacji (ręczny, konfiguracyjny / kompilacyjny lub kreator) powinien obsłużyć tworzenie i wypełnianie nowego pliku. Opcjonalnie zmodyfikuj uprawnienia do pliku, aby zapewnić, że tylko wymagany użytkownik (serwer internetowy?) Może go odczytać.

Korzyści:

• Nie zakłada bytu programistycznego == bytu produkcyjnego
• Nie zakłada się, że wszyscy współpracownicy / recenzenci kodu są zaufani
• Zapobiegaj łatwym błędom, utrzymując je poza kontrolą wersji
• Łatwa do zautomatyzowania instalacja z niestandardową konfiguracją dla kontroli jakości / kompilacji

Jeśli już to robisz i przypadkowo je zameldujesz, dodaj je do projektu .gitignore. Uniemożliwi to powtórzenie.

Wokół jest wiele darmowych hostów Git, które zapewniają prywatne repozytoria. Chociaż nigdy nie powinieneś aktualizować swoich danych uwierzytelniających, możesz być tani i mieć również prywatne repozytoria. ^ _ ^

Zamiast mieć gdziekolwiek klucz OAuth przechowywany jako surowe dane, dlaczego nie uruchomić łańcucha przez jakiś algorytm szyfrujący i zapisać go jako solony skrót? Następnie użyj pliku konfiguracyjnego, aby przywrócić go w czasie wykonywania. W ten sposób klucz nie jest nigdzie przechowywany, niezależnie od tego, czy jest przechowywany na pudełku programistycznym, czy na samym serwerze.

Możesz nawet utworzyć interfejs API, dzięki któremu Twój serwer automatycznie wygeneruje nowy solony i zakodowany klucz API na podstawie żądania, w ten sposób nawet twój zespół nie będzie widział źródła OAuth.

Edycja: Być może wypróbuj bibliotekę kryptograficzną Javascript Stanford , pozwala ona na dość bezpieczne szyfrowanie / deszyfrowanie symetryczne.