C ++ 'da hassas dizeleri gizleme teknikleri

C ++ uygulamamda hassas bilgileri (gizli tutmak istediğim simetrik bir şifreleme anahtarı) depolamam gerekiyor. Basit yaklaşım, bunu yapmaktır:

std::string myKey = "mysupersupersecretpasswordthatyouwillneverguess";

Ancak, uygulamayı stringsişlem aracılığıyla (veya bir ikili uygulamadan dizeleri çıkaran herhangi bir başka yöntem) çalıştırmak yukarıdaki dizeyi ortaya çıkaracaktır.

Bu tür hassas verileri gizlemek için hangi teknikler kullanılmalıdır?

Düzenle:

Tamam, neredeyse hepiniz "çalıştırılabilir dosyanız tersine mühendislik yapılabilir" dediniz - tabii ki! Bu benim bir evcil hayvanım, bu yüzden burada biraz rant yapacağım:

Neden bu sitedeki güvenlikle ilgili tüm soruların% 99'u (tamam, belki biraz abartıyorum) "tamamen güvenli bir program oluşturmanın mümkün bir yolu yok" torrentiyle yanıtlanıyor - bu bir yardımcı değil Cevap! Güvenlik, mükemmel kullanılabilirlik ile bir uçta güvenlik olmaması ve diğer tarafta mükemmel güvenlik, ancak kullanılabilirlik olmaması arasında değişen bir ölçektir.

Mesele şu ki, ne yapmaya çalıştığınıza ve yazılımınızın çalışacağı ortama bağlı olarak o kayan ölçekte konumunuzu seçiyorsunuz. Askeri kurulum için bir uygulama yazmıyorum, bir ev bilgisayarı için bir uygulama yazıyorum . Güvenilmeyen bir ağdaki verileri önceden bilinen bir şifreleme anahtarıyla şifrelemem gerekiyor. Bu durumlarda, "belirsizlik yoluyla güvenlik" muhtemelen yeterince iyidir! Elbette, yeterli zamana, enerjiye ve beceriye sahip biri ikili programa tersine mühendislik uygulayabilir ve parolayı bulabilir, ama bilin bakalım ne oldu? Umrumda değil:

Birinci sınıf bir güvenli sistemi uygulamak için harcadığım süre, crackli sürümler nedeniyle satış kaybından daha pahalıdır (aslında bunu sattığımdan değil, ama benim fikrimi anladınız). Yeni programcılar arasında programlamadaki bu mavi gökyüzü "mümkün olan en iyi şekilde yapalım" eğilimi en azından aptalca.

Bu soruyu yanıtlamak için zaman ayırdığınız için teşekkür ederiz - çok yardımcı oldular. Ne yazık ki sadece bir cevabı kabul edebiliyorum, ancak tüm faydalı cevapları yukarı oyladım.

Temelde, sizin programa erişimi ve ayıklayıcıya olan herkes olabilir ve olacaktır dilerlerse uygulamasında anahtar bulmak.

Ancak, stringsikili programınızda çalışırken anahtarın görünmediğinden emin olmak istiyorsanız, örneğin anahtarın yazdırılabilir aralıkta olmadığından emin olabilirsiniz.

XOR ile gizli anahtar

Örneğin, anahtarı iki bayt dizisine ayırmak için XOR kullanabilirsiniz:

key = key1 XOR key2

keyRastgele bayt değerleri (tamamen) kullanabileceğiniz ve ardından hesaplayabileceğiniz aynı bayt uzunluğuna sahip key1 oluşturursanız key2:

key1[n] = crypto_grade_random_number(0..255)
key2[n] = key[n] XOR key1[n]

Eğer yapı ortamında bunu yapmak ve sonra sadece saklayabilir key1ve key2uygulamanızda.

İkili programınızı korumak

Diğer bir yaklaşım, ikili dosyanızı korumak için bir araç kullanmaktır. Örneğin, ikili programınızın gizlendiğinden ve üzerinde çalıştığı bir sanal makineyi başlattığından emin olabilen birkaç güvenlik aracı vardır. Bu, hata ayıklamayı zorlaştırır ve aynı zamanda birçok ticari sınıf güvenli uygulamanın (ne yazık ki, kötü amaçlı yazılım) korunmasının geleneksel yoludur.

En önemli araçlardan biri , ikili dosyalarınızı korumak için harika bir iş çıkaran Themida'dır . Ters mühendisliğe karşı korumak için genellikle Spotify gibi iyi bilinen programlar tarafından kullanılır. OllyDbg ve Ida Pro gibi programlarda hata ayıklamayı engelleyen özelliklere sahiptir.

İkili programınızı korumak için daha büyük, belki biraz eskimiş araçlar listesi de var .
Bazıları ücretsizdir.

Parola eşleştirme

Burada birisi hashing password + salt'ı tartıştı.

Anahtarı, kullanıcı tarafından gönderilen bir tür parolayla eşleştirmek için saklamanız gerekiyorsa, tercihen kullanıcı adı, parola ve bir tuzu birleştirerek tek yönlü bir karma işlevi kullanmalısınız. Bununla ilgili sorun, uygulamanızın tek yönlü yapabilmesi ve sonuçta ortaya çıkan hash'leri karşılaştırabilmesi için tuzu bilmesi gerektiğidir. Bu nedenle, tuzu yine de uygulamanızda bir yerde saklamanız gerekir. Ancak, @Edward'ın aşağıdaki yorumlarda işaret ettiği gibi, bu, örneğin gökkuşağı tabloları kullanan bir sözlük saldırısına karşı etkili bir şekilde koruma sağlayacaktır.

Son olarak, yukarıdaki tüm tekniklerin bir kombinasyonunu kullanabilirsiniz.

Her şeyden önce, yeterince kararlı bir hacker'ı durduracak hiçbir şey yapamayacağınızın farkına varın ve etrafta pek çok kişi var. Her oyun ve konsoldaki koruma sonunda kırılır, bu nedenle bu yalnızca geçici bir çözümdür.

Bir süre gizli kalma şansınızı artıracak yapabileceğiniz 4 şey var.

1) Dizenin öğelerini bir şekilde gizleyin - xoring (^ operatörü) gibi aşikar bir şey, başka bir dizgiye sahip dizge, dizeyi aramayı imkansız hale getirecek kadar iyi olacaktır.

2) Dizeyi parçalara ayırın - dizenizi bölün ve onun bitlerini garip modüllerdeki garip adlandırılmış yöntemlere ayırın. İçinde dize bulunan yöntemi aramayı ve bulmayı kolaylaştırmayın. Elbette bazı yöntemlerin tüm bu bitleri çağırması gerekecek, ancak yine de biraz daha zorlaştırıyor.

3) Dizeyi asla bellekte oluşturmayın - çoğu bilgisayar korsanı, siz onu kodladıktan sonra bellekteki dizeyi görmelerine izin veren araçlar kullanır. Mümkünse bundan kaçının. Örneğin, anahtarı bir sunucuya gönderiyorsanız, onu karakter karakter gönderin, böylece dizenin tamamı hiçbir zaman ortalıkta kalmaz. Tabii ki, RSA kodlaması gibi bir şeyden kullanıyorsanız, bu daha zordur.

4) Geçici bir algoritma yapın - tüm bunlara ek olarak, benzersiz bir veya iki bükülme ekleyin. Belki ürettiğiniz her şeye 1 ekleyin veya herhangi bir şifreleme işlemini iki kez yapın veya bir şeker ekleyin. Bu, örneğin vanilya md5 hashing veya RSA şifreleme kullandığında neye bakacağını zaten bilen bilgisayar korsanı için işi biraz daha zorlaştırır.

Hepsinden önemlisi, anahtarınızın ne zaman keşfedildiği (ve uygulamanız yeterince popüler hale geldiğinde olacaktır) çok önemli olmadığından emin olun!

Geçmişte kullandığım bir strateji, görünüşte rastgele karakterlerden oluşan bir dizi oluşturmaktır. Başlangıçta belirli karakterlerinizi eklersiniz ve ardından 0'dan N'ye kadar olan her adımın, gizlenmiş dizenizdeki bir sonraki karakteri içeren dizinin bir sayı <boyutunu vereceği bir cebirsel işlemle konumlandırırsınız. (Bu cevap şimdi şaşırmış gibi geliyor!)

Misal:

Bir dizi karakter verildiğinde (sayılar ve çizgiler yalnızca referans içindir)

0123456789
----------
ALFHNFELKD
LKFKFLEHGT
FLKRKLFRFK
FJFJJFJ!JL

Ve ilk altı sonucu 3, 6, 7, 10, 21, 47 olan bir denklem

"MERHABA" kelimesini verirdi! yukarıdaki diziden.

@Checkers'a katılıyorum, çalıştırılabilir dosyanız tersine mühendislik yapılabilir.

Biraz daha iyi bir yol, onu dinamik olarak oluşturmaktır, örneğin:

std::string myKey = part1() + part2() + ... + partN();

Elbette, kullanıcıya gönderilen yazılımda özel verilerin saklanması her zaman bir risktir. Yeterince eğitimli (ve kendini işine adamış) herhangi bir mühendis, verilere tersine mühendislik uygulayabilir.

Bununla birlikte, insanların özel verilerinizi ifşa etmek için aşması gereken engeli yükselterek işleri yeterince güvenli hale getirebilirsiniz. Bu genellikle iyi bir uzlaşmadır.

Sizin durumunuzda, dizelerinizi yazdırılamayan verilerle karıştırabilir ve ardından bunu çalışma zamanında basit bir yardımcı işlev kullanarak şu şekilde çözebilirsiniz:

void unscramble( char *s )
{
    for ( char *str = s + 1; *str != 0; str += 2 ) {
        *s++ = *str;
    }
    *s = '\0';
}

void f()
{
    char privateStr[] = "\001H\002e\003l\004l\005o";
    unscramble( privateStr ); // privateStr is 'Hello' now.

    string s = privateStr;
    // ...
}

Dizeler için basit bir şifreleme aracı oluşturdum, otomatik olarak şifrelenmiş dizeler oluşturabilir ve bunu yapmak için birkaç ekstra seçeneğe sahiptir, birkaç örnek:

Global değişken olarak dizge:

// myKey = "mysupersupersecretpasswordthatyouwillneverguess";
unsigned char myKey[48] = { 0xCF, 0x34, 0xF8, 0x5F, 0x5C, 0x3D, 0x22, 0x13, 0xB4, 0xF3, 0x63, 0x7E, 0x6B, 0x34, 0x01, 0xB7, 0xDB, 0x89, 0x9A, 0xB5, 0x1B, 0x22, 0xD4, 0x29, 0xE6, 0x7C, 0x43, 0x0B, 0x27, 0x00, 0x91, 0x5F, 0x14, 0x39, 0xED, 0x74, 0x7D, 0x4B, 0x22, 0x04, 0x48, 0x49, 0xF1, 0x88, 0xBE, 0x29, 0x1F, 0x27 };

myKey[30] -= 0x18;
myKey[39] -= 0x8E;
myKey[3] += 0x16;
myKey[1] += 0x45;
myKey[0] ^= 0xA2;
myKey[24] += 0x8C;
myKey[44] ^= 0xDB;
myKey[15] ^= 0xC5;
myKey[7] += 0x60;
myKey[27] ^= 0x63;
myKey[37] += 0x23;
myKey[2] ^= 0x8B;
myKey[25] ^= 0x18;
myKey[12] ^= 0x18;
myKey[14] ^= 0x62;
myKey[11] ^= 0x0C;
myKey[13] += 0x31;
myKey[6] -= 0xB0;
myKey[22] ^= 0xA3;
myKey[43] += 0xED;
myKey[29] -= 0x8C;
myKey[38] ^= 0x47;
myKey[19] -= 0x54;
myKey[33] -= 0xC2;
myKey[40] += 0x1D;
myKey[20] -= 0xA8;
myKey[34] ^= 0x84;
myKey[8] += 0xC1;
myKey[28] -= 0xC6;
myKey[18] -= 0x2A;
myKey[17] -= 0x15;
myKey[4] ^= 0x2C;
myKey[9] -= 0x83;
myKey[26] += 0x31;
myKey[10] ^= 0x06;
myKey[16] += 0x8A;
myKey[42] += 0x76;
myKey[5] ^= 0x58;
myKey[23] ^= 0x46;
myKey[32] += 0x61;
myKey[41] ^= 0x3B;
myKey[31] ^= 0x30;
myKey[46] ^= 0x6C;
myKey[35] -= 0x08;
myKey[36] ^= 0x11;
myKey[45] -= 0xB6;
myKey[21] += 0x51;
myKey[47] += 0xD9;

Şifre çözme döngüsüne sahip unicode dizesi olarak:

// myKey = "mysupersupersecretpasswordthatyouwillneverguess";
wchar_t myKey[48];

myKey[21] = 0x00A6;
myKey[10] = 0x00B0;
myKey[29] = 0x00A1;
myKey[22] = 0x00A2;
myKey[19] = 0x00B4;
myKey[33] = 0x00A2;
myKey[0] = 0x00B8;
myKey[32] = 0x00A0;
myKey[16] = 0x00B0;
myKey[40] = 0x00B0;
myKey[4] = 0x00A5;
myKey[26] = 0x00A1;
myKey[18] = 0x00A5;
myKey[17] = 0x00A1;
myKey[8] = 0x00A0;
myKey[36] = 0x00B9;
myKey[34] = 0x00BC;
myKey[44] = 0x00B0;
myKey[30] = 0x00AC;
myKey[23] = 0x00BA;
myKey[35] = 0x00B9;
myKey[25] = 0x00B1;
myKey[6] = 0x00A7;
myKey[27] = 0x00BD;
myKey[45] = 0x00A6;
myKey[3] = 0x00A0;
myKey[28] = 0x00B4;
myKey[14] = 0x00B6;
myKey[7] = 0x00A6;
myKey[11] = 0x00A7;
myKey[13] = 0x00B0;
myKey[39] = 0x00A3;
myKey[9] = 0x00A5;
myKey[2] = 0x00A6;
myKey[24] = 0x00A7;
myKey[46] = 0x00A6;
myKey[43] = 0x00A0;
myKey[37] = 0x00BB;
myKey[41] = 0x00A7;
myKey[15] = 0x00A7;
myKey[31] = 0x00BA;
myKey[1] = 0x00AC;
myKey[47] = 0x00D5;
myKey[20] = 0x00A6;
myKey[5] = 0x00B0;
myKey[38] = 0x00B0;
myKey[42] = 0x00B2;
myKey[12] = 0x00A6;

for (unsigned int fngdouk = 0; fngdouk < 48; fngdouk++) myKey[fngdouk] ^= 0x00D5;

Global değişken olarak dizge:

// myKey = "mysupersupersecretpasswordthatyouwillneverguess";
unsigned char myKey[48] = { 0xAF, 0xBB, 0xB5, 0xB7, 0xB2, 0xA7, 0xB4, 0xB5, 0xB7, 0xB2, 0xA7, 0xB4, 0xB5, 0xA7, 0xA5, 0xB4, 0xA7, 0xB6, 0xB2, 0xA3, 0xB5, 0xB5, 0xB9, 0xB1, 0xB4, 0xA6, 0xB6, 0xAA, 0xA3, 0xB6, 0xBB, 0xB1, 0xB7, 0xB9, 0xAB, 0xAE, 0xAE, 0xB0, 0xA7, 0xB8, 0xA7, 0xB4, 0xA9, 0xB7, 0xA7, 0xB5, 0xB5, 0x42 };

for (unsigned int dzxykdo = 0; dzxykdo < 48; dzxykdo++) myKey[dzxykdo] -= 0x42;

Joshperry'nin de belirttiği gibi, korumaya çalıştığınız şeye biraz bağlı. Deneyimlerime göre, yazılımınızı korumak için bazı lisanslama planlarının bir parçasıysa, o zaman zahmet etmeyin derim. Sonunda tersine mühendislik yapacaklar. Basit saldırılardan korumak için basitçe ROT-13 gibi basit bir şifre kullanın (üzerinde satır çalıştırma). Kullanıcıların hassas verilerini güvence altına almaksa, bu verileri yerel olarak depolanan özel bir anahtarla korumanın akıllıca bir hareket olup olmadığını sorguluyor olurum. Yine korumaya çalıştığınız şeye bağlı.

DÜZENLEME: Eğer bunu yapacaksanız, o zaman Chris'in işaret ettiği bir teknik kombinasyonu rot13'ten çok daha iyi olacaktır.

Daha önce de söylendiği gibi, ipinizi tamamen korumanın bir yolu yok. Ancak onu korumanın yolları var, makul bir güvenlik.

Bunu yapmak zorunda olduğumda, koda masum görünen bir dizi (örneğin bir telif hakkı bildirimi veya sahte bir kullanıcı istemi veya ilgisiz bir kodu düzelten biri tarafından değiştirilmeyecek herhangi bir şey) ekledim ve bunu kendi kendini kullanarak şifreledim bir anahtar olarak, bunu karma haline getirdim (biraz tuz ekleyerek) ve sonucu, şifrelemek istediğim şeyi şifrelemek için bir anahtar olarak kullandım.

Elbette bu saldırıya uğrayabilir, ancak bunu yapmak için kararlı bir bilgisayar korsanı gerekir.

Windows kullanıcısı DPAPI kullanıyorsanız, http://msdn.microsoft.com/en-us/library/ms995355.aspx

Önceki bir gönderide söylendiği gibi, Mac kullanıyorsanız anahtar zincirini kullanın.

Temel olarak, özel anahtarınızı ikili programınızda nasıl saklayacağınızla ilgili tüm bu sevimli fikirler, güvenlik açısından bunları yapmamanız gereken kadar zayıftır. Özel anahtarınızı alan biri çok önemli, onu programınızın içinde tutmayın. Uygulamanızın ne kadar içe aktarıldığına bağlı olarak, özel anahtarlarınızı bir akıllı kartta, kodunuzun konuştuğu uzak bir bilgisayarda tutabilir veya çoğu insanın yaptığı şeyi yapabilir ve yerel bilgisayarda çok güvenli bir yerde ("anahtar" store "bu tuhaf bir güvenli kayıt defteri gibi) izinlerle ve işletim sisteminizin tüm gücüyle korunur.

Bu çözülmüş bir sorundur ve cevap, anahtarı programınızın içinde tutmak DEĞİLDİR :)

Deneyin bu . Kaynak kodu, belirli bir Visual Studio c ++ projesindeki tüm dizelerin anında nasıl şifreleneceğini ve şifresinin nasıl çözüleceğini açıklar.

Yakın zamanda denediğim yöntemlerden biri:

1. Özel verilerin karmasını (SHA256) alın ve kodda şu şekilde doldurun: part1
2. Özel verilerin XOR'unu ve hash'ini alın ve kod içinde şu şekilde doldurun: part2
3. Verileri doldurun: Bunu char str [] olarak saklamayın, ancak atama talimatlarını kullanarak çalışma zamanında doldurun (aşağıdaki makroda gösterildiği gibi)
4. Şimdi, özel verileri çalışma zamanında oluşturmak için XOR part1vepart2
5. Ek adım : Oluşturulan verilerin karmasını hesaplayın ve bununla karşılaştırın part1. Özel verilerin bütünlüğünü doğrulayacaktır.

Verileri doldurmak için MACRO:

Özel verilerin 4 bayt olduğunu varsayalım. Verileri atama talimatlarıyla rastgele bir sırayla kaydeden bir makro tanımlıyoruz.

#define POPULATE_DATA(str, i0, i1, i2, i3)\
{\
    char *p = str;\
    p[3] = i3;\
    p[2] = i2;\
    p[0] = i0;\
    p[1] = i1;\
}

Şimdi bu makroyu kaydetmeniz gereken kodda part1ve part2aşağıdaki gibi kullanın:

char part1[4] = {0};
char part2[4] = {0};
POPULATE_DATA(part1, 1, 2, 3, 4); 
POPULATE_DATA(part2, 5, 6, 7, 8);

Adamyaxley tarafından yapılan ve mükemmel çalışan (çok hafif) yalnızca başlık içeren bir proje karartması var . Lambda işlevlerine ve makrolara dayanır ve dizeleri derleme zamanında bir XOR şifresiyle birlikte şifreler. Gerekirse, her dizge için tohumu değiştirebiliriz.

Aşağıdaki kod, derlenmiş ikili dosyadaki "merhaba dünya" dizesini saklamayacaktır.

#include "obfuscate.h"

int main()
{
  std::cout << AY_OBFUSCATE("Hello World") << std::endl;
  return 0;
}

C ++ 17 ve visual studio 2019 ile test ettim ve IDA ile kontrol ettim ve dizenin gizli olduğunu onaylıyorum. ADVobfuscator ile karşılaştırıldığında değerli bir avantaj , std :: string'e dönüştürülebilir olmasıdır (hala derlenmiş ikili dosyada gizlenmiş haldeyken):

std::string var = AY_OBFUSCATE("string");

Özel anahtarı çalıştırılabilir dosyanızda saklamak yerine, kullanıcıdan talep etmek ve Mac OS X Anahtar Zinciri Erişimi'ne benzer bir şekilde harici bir parola yöneticisi aracılığıyla saklamak isteyebilirsiniz .

Bağlama bağlıdır, ancak anahtarın karmasını ve bir tuzunu (sabit dizgi, anlaşılması kolay) depolayabilirsiniz .

Daha sonra, kullanıcı anahtarı girdiğinde (eğer), tuzu eklersiniz , karmayı hesaplar ve karşılaştırırsınız.

Tuz karma izole edilebilirse bu durumda muhtemelen gereksizdir, bir kaba kuvvet sözlük saldırısı durur (bir Google arama çalışmalarına da biliyorum olmuştur).

Bir bilgisayar korsanı, her şeyi atlatmak için bir yere sadece bir jmp talimatı eklemek zorundadır, ancak bu basit bir metin aramasından çok daha karmaşıktır.