Bir kimliği gizleme

Bir tamsayı kimliğini başka bir tam sayıya şifrelemek / gizlemek için bir yol arıyorum. Daha doğrusu, bir işleve ihtiyacım var int F(int x), böylece

• x <-> F (x) bire bir yazışmadır (eğer x! = y, F (x)! = F (y))
• F (x) verildiğinde, x'i bulmak kolaydır - dolayısıyla F bir hash fonksiyonu değildir
• x ve F (x) verildiğinde, F (y) 'yi bulmak zor / imkansız, gibi bir şey x ^ 0x1234çalışmayacak

Netlik için, güçlü bir şifreleme çözümü aramıyorum, bu sadece şaşırtma. Gibi adresler ile bir web uygulaması düşünün example.com/profile/1, example.com/profile/2kendileri gizli değildir vb profilleri, ama ben böyle bir şey arkasında bunları gizlemek yerine ediyorum, böylece tüm profiller birbiri ardına getirme / görünümüne gündelik röntgencileri engellemek istiyorsunuz example.com/profile/23423, example.com/profile/80980234vs. rağmen Veritabanında depolanan belirteçler işi oldukça kolay bir şekilde yapabilir, bunun için basit bir matematik olup olmadığını merak ediyorum.

Ben yaklaşık temizlemek değildi Önemli bir gereklilik sonuçları, bir dizi verildiği, "rastgele" bakmak gerektiğidir x,x+1,...,x+n, F(x),F(x+1)...F(x+n)herhangi türden bir ilerleme oluşmamalıdır.

Bunu 2 veya 3 basit yöntemin bir kombinasyonu ile karıştırın:

• ÖZELVEYA
• tek tek bitleri karıştır
• modüler gösterime dönüştür (D.Knuth, Cilt 2, Bölüm 4.3.2)
• her alt kümede 32 (veya 64) üst üste binen bit ve XOR bit alt kümesini seçin (alt kümelerin eşlik bitleri)
• onu değişken uzunluklu sayısal sistemde temsil edin ve basamakları karıştırın
• tek tamsayı çifti seçmek xve ybirbirlerine (modülo 2 çarpımsal tersidir yani ³² ), ile çarpıyoruz xkarartmak için ve çarpma yoluyla ygeri, tüm çarpmalar modül 2 olan ³² (kaynak: Eric "Çarpımsal terslerinin bir pratik kullanımı" Lippert )

Değişken uzunluklu sayısal sistem yöntemi kendi başına "ilerleme" gereksinimlerinize uymaz. Her zaman kısa aritmetik ilerlemeler üretir. Ancak başka bir yöntemle birleştirildiğinde iyi sonuçlar verir.

Aynısı modüler gösterim yöntemi için de geçerlidir.

İşte bu yöntemlerden 3'ü için C ++ kod örneği. Karışık bit örneği, daha tahmin edilemez olması için bazı farklı maskeler ve mesafeler kullanabilir. Diğer 2 örnek küçük sayılar için iyidir (sadece fikir vermek için). Tüm tam sayı değerlerini doğru bir şekilde gizlemek için genişletilmelidirler.

// *** Numberic system base: (4, 3, 5) -> (5, 3, 4)
// In real life all the bases multiplied should be near 2^32
unsigned y = x/15 + ((x/5)%3)*4 + (x%5)*12; // obfuscate
unsigned z = y/12 + ((y/4)%3)*5 + (y%4)*15; // restore

// *** Shuffle bits (method used here is described in D.Knuth's vol.4a chapter 7.1.3)
const unsigned mask1 = 0x00550055; const unsigned d1 = 7;
const unsigned mask2 = 0x0000cccc; const unsigned d2 = 14;

// Obfuscate
unsigned t = (x ^ (x >> d1)) & mask1;
unsigned u = x ^ t ^ (t << d1);
t = (u ^ (u  >> d2)) & mask2;
y = u ^ t ^ (t << d2);

// Restore
t = (y ^ (y >> d2)) & mask2;
u = y ^ t ^ (t << d2);
t = (u ^ (u >> d1)) & mask1;
z = u ^ t ^ (t << d1);

// *** Subset parity
t = (x ^ (x >> 1)) & 0x44444444;
u = (x ^ (x << 2)) & 0xcccccccc;
y = ((x & 0x88888888) >> 3) | (t >> 1) | u; // obfuscate

t = ((y & 0x11111111) << 3) | (((y & 0x11111111) << 2) ^ ((y & 0x22222222) << 1));
z = t | ((t >> 2) ^ ((y >> 2) & 0x33333333)); // restore

Dönüşümün tersine çevrilebilir olmasını ve açık olmamasını istiyorsunuz. Bu, belirli bir aralıktaki bir sayıyı alan ve aynı aralıkta farklı bir sayı üreten bir şifrelemeye benziyor. Aralığınız 64 bitlik sayılar ise, DES kullanın. Aralığınız 128 bitlik sayılar ise AES kullanın. Farklı bir aralık istiyorsanız, o zaman en iyi bahsiniz muhtemelen Hasty Pudding şifresidir ; farklı blok boyutları ve 100.000 ila 999.999 gibi bir bloğa düzgün bir şekilde sığmayan sayı aralıklarıyla başa çıkmak için tasarlanmıştır.

Gizleme, güvenlik açısından gerçekten yeterli değil.

Bununla birlikte, sıradan izleyiciyi engellemeye çalışıyorsanız, iki yöntemin bir kombinasyonunu öneririm:

• Kimlik ile bunları birlikte xor'layarak birleştirdiğiniz özel bir anahtar
• Anahtarın uygulanmasından önce ve sonra bitleri belirli bir miktarda döndürmek

İşte bir örnek (sözde kod kullanarak):

  def F(x)
    x = x XOR 31415927       # XOR x with a secret key
    x = rotl(x, 5)           # rotate the bits left 5 times
    x = x XOR 31415927       # XOR x with a secret key again
    x = rotr(x, 5)           # rotate the bits right 5 times
    x = x XOR 31415927       # XOR x with a secret key again
    return x                 # return the value
  end

Test etmedim, ancak bence bu tersine çevrilebilir, hızlı olmalı ve yöntemi ortaya çıkarmak çok kolay değil.

Bu belirli Python / PHP kodunu çok yararlı buldum:

https://github.com/marekweb/opaque-id

Bu konudaki bazı fikirleri kullanarak bazı JS kodu yazdım:

const BITS = 32n;
const MAX = 4294967295n;
const COPRIME = 65521n;
const INVERSE = 2166657316n;
const ROT = 6n;
const XOR1 = 10296065n; 
const XOR2 = 2426476569n;


function rotRight(n, bits, size) {
    const mask = (1n << bits) - 1n;
    // console.log('mask',mask.toString(2).padStart(Number(size),'0'));
    const left = n & mask;
    const right = n >> bits;
    return (left << (size - bits)) | right;
}

const pipe = fns => fns.reduce((f, g) => (...args) => g(f(...args)));

function build(...fns) {
    const enc = fns.map(f => Array.isArray(f) ? f[0] : f);
    const dec = fns.map(f => Array.isArray(f) ? f[1] : f).reverse();

    return [
        pipe(enc),
        pipe(dec),
    ]
}

[exports.encode, exports.decode] = build(
    [BigInt, Number],
    [i => (i * COPRIME) % MAX, i => (i * INVERSE) % MAX],
    x => x ^ XOR1,
    [x => rotRight(x, ROT, BITS), x => rotRight(x, BITS-ROT, BITS)],
    x => x ^ XOR2,
);

Aşağıdakiler gibi bazı güzel sonuçlar verir:

1 1352888202n 1 'mdh37u'
2 480471946n 2 '7y26iy'
3 3634587530n 3 '1o3xtoq'
4 2225300362n 4 '10svwqy'
5 1084456843n 5 'hxno97'
6 212040587n 6 '3i8rkb'
7 3366156171n 7 '1jo4eq3'
8 3030610827n 8 '1e4cia3'
9 1889750920n 9 'v93x54'
10 1017334664n 10 'gtp0g8'
11 4171450248n 11 '1wzknm0'
12 2762163080n 12 '19oiqo8'
13 1621319561n 13 'qtai6h'
14 748903305n 14 'cdvlhl'
15 3903018889n 15 '1sjr8nd'
16 3567473545n 16 '1mzzc7d'
17 2426613641n 17 '144qr2h'
18 1554197390n 18 'ppbudq'
19 413345678n 19 '6u3fke'
20 3299025806n 20 '1ik5klq'
21 2158182286n 21 'zoxc3y'
22 1285766031n 22 'l9iff3'
23 144914319n 23 '2ea0lr'
24 4104336271n 24 '1vvm64v'
25 2963476367n 25 '1d0dkzz'
26 2091060108n 26 'ykyob0'
27 950208396n 27 'fpq9ho'
28 3835888524n 28 '1rfsej0'
29 2695045004n 29 '18kk618'
30 1822628749n 30 'u559cd'
31 681777037n 31 'b9wuj1'
32 346231693n 32 '5q4y31'

Şunlarla test ediliyor:

  const {encode,decode} = require('./obfuscate')

  for(let i = 1; i <= 1000; ++i) {
        const j = encode(i);
        const k = decode(j);
        console.log(i, j, k, j.toString(36));
   }

XOR1ve XOR20 ile arasındaki rastgele sayılardır MAX. MAXis 2**32-1; bunu en yüksek kimliğinizin olacağını düşündüğünüz şeye ayarlamalısınız.

COPRIMEbir sayıdır MAX. Ben düşünüyorum kendilerini (kendileri katları hariç) diğer her sayı ile aralarında asal olan asal sayılar.

INVERSEanlaşılması zor olandır. Bu blog gönderileri net bir cevap vermez, ancak WolframAlpha sizin için çözebilir . Temel olarak, sadece denklemi çözmek (COPRIME * x) % MAX = 1için x.

buildİşlev daha kolay bu şifreleme / şifre çözme boru hatlarını oluşturmak için yapmak için oluşturulan bir şey olduğunu. [encode, decode]Çiftler halinde istediğiniz kadar işlemi besleyebilirsiniz . Bu işlevler eşit ve zıt olmalıdır. XOREğer bir çift var gerekmez işlevleri kendi ikramıdır.

İşte başka bir eğlenceli buluş :

function mixHalves(n) {
    const mask = 2n**12n-1n;
    const right = n & mask;
    const left = n >> 12n;
    const mix = left ^ right;
    return (mix << 12n) | right;
}

(24 bitlik tam sayılar varsayılır - sadece başka bir boyut için sayıları değiştirin)

Kimlik parçalarıyla onları yok etmeyecek her şeyi yapın. Örneğin:

• değeri döndür
• değerin belirli kısımlarını değiştirmek için aramayı kullanın
• xor bazı değerlerle
• takas bitleri
• baytları değiştir
• tüm değeri yansıt
• değerin bir bölümünü yansıtmak
• ... hayal gücünü kullan

Şifre çözme için, hepsini ters sırada yapın.

Sizin için bazı ilginç değerleri 'şifreleyecek' bir program oluşturun ve bunları inceleyebileceğiniz bir tabloya koyun. Aynı programa sahip olun, şifreleme / şifre çözme rutininizi, sisteminizde olmasını istediğiniz tüm değerler ile TEST EDİN.

Numaralarınız size düzgün bir şekilde karıştırılmış görünene kadar yukarıdaki listeye bir şeyler ekleyin.

Diğer her şey için Kitap'ın bir kopyasını alın .

Gereksinimlerinizi belirtildiği gibi karşılaması gereken blok şifreli güvenli permütasyonlar hakkında bir makale yazdım .

Bununla birlikte, tanımlayıcıları tahmin etmek zor istiyorsanız, bunları ilk başta kullanmanız gerektiğini öneririm: UUID'ler oluşturun ve bunları ilk olarak kayıtlarınız için birincil anahtar olarak kullanın - bunu yapmanıza gerek yoktur 'gerçek' bir kimliğe dönüştürmek için.

Ne kadar "zor" olması gerektiğinden, ne kadar hızlı olduğundan veya ne kadar az bellek kullanacağından emin değilsin. Bellek kısıtlamanız yoksa, tüm tam sayıların bir listesini yapabilir, onları karıştırabilir ve bu listeyi bir eşleme olarak kullanabilirsiniz. Ancak, 4 baytlık bir tamsayı için bile çok fazla belleğe ihtiyacınız olacaktır.

Bununla birlikte, bu daha küçük yapılabilir, böylece tüm tam sayıları eşlemek yerine yalnızca 2 (veya en kötü durum 1) baytı eşleştirir ve bunu tam sayıdaki her gruba uygularsınız. Bu nedenle, 2 bayt kullanarak bir tamsayı (grup1) (grup2) olacaktır, her bir grubu rastgele harita üzerinden eşlersiniz . Ancak bu, yalnızca grup2'yi değiştirirseniz, grup1 eşlemesinin aynı kalacağı anlamına gelir. Bu, her bir gruba farklı bitleri eşleyerek "düzeltilebilir".

Yani, * (2.Grup) olabilir (bit 14,12,10,8,6,4,2,0) böylece, 1 ekleme hem değiştirecek grup1 ve grup2 .

Yine de, bu yalnızca belirsizlikten kaynaklanan güvenliktir, işlevinize sayılar besleyebilen herkes (işlevi gizli tutsanız bile) oldukça kolay bir şekilde anlayabilir.

Uygulamanızda kullanmak için özel bir simetrik anahtar oluşturun ve bununla tamsayınızı şifreleyin. Bu, en zor # 3 dahil olmak üzere üç gereksinimi de karşılayacaktır: planınızı bozmak için anahtarınızı tahmin etmeniz gerekir.

Burada tarif ettiğiniz şey tek yönlü bir işlevin tam tersi gibi görünüyor: tersine çevirmek kolay ama uygulaması çok zor. Bir seçenek, bir sır olarak sakladığınız (gizli, rastgele seçilmiş) bir genel anahtarı ve dünyayla paylaştığınız özel bir anahtarı düzelttiğiniz standart, kullanıma hazır bir açık anahtar şifreleme algoritması kullanmak olabilir. Bu şekilde, F (x) fonksiyonunuz x'in genel anahtar kullanılarak şifrelenmesi olacaktır. Daha sonra, özel şifre çözme anahtarını kullanarak F (x) 'in şifresini kolayca x'e geri döndürebilirsiniz. Burada genel ve özel anahtar rollerinin tersine çevrildiğine dikkat edin - özel anahtarı herkese verirsiniz, böylece işlevin şifresini çözebilirler, ancak genel anahtarı sunucunuzda gizli tutabilirsiniz. Bu şekilde:

1. Fonksiyon bir bijeksiyondur, bu yüzden tersinirdir.
2. F (x) verildiğinde, x verimli bir şekilde hesaplanabilir.
3. X ve F (x) göz önüne alındığında, F (y) 'yi y'den hesaplamak son derece zordur, çünkü açık anahtar olmadan (kriptografik olarak güçlü bir şifreleme şeması kullandığınız varsayılarak), özel olsa bile verileri şifrelemenin uygun bir yolu yoktur. şifre çözme anahtarı bilinmektedir.

Bunun birçok avantajı vardır. Öncelikle, kripto sisteminin güvenli olduğundan emin olabilirsiniz, çünkü RSA gibi köklü bir algoritma kullanıyorsanız kazara güvensizlik konusunda endişelenmenize gerek kalmaz. İkincisi, bunu yapmak için zaten kitaplıklar var, bu nedenle çok fazla kod yazmanıza gerek kalmaz ve yan kanal saldırılarına karşı bağışık olabilirsiniz. Son olarak, hiç kimse F (x) 'i gerçekten hesaplayamadan herhangi birinin gidip F (x)' i ters çevirmesini mümkün kılabilirsiniz.

Bir ayrıntı - burada kesinlikle sadece standart int türünü kullanmamalısınız. 64 bitlik tamsayılarla bile, bir saldırganın anahtara sahip olmasa bile bazı y için F (y) şifrelemesini bulana kadar her şeyi kaba kuvvetle tersine çevirmeyi deneyebileceği çok az kombinasyon vardır. Bir bilim kurgu saldırısı bile bunu kaba kuvvet uygulayamayacağından, 512 bitlik bir değer gibi bir şey kullanmanızı öneririm.

Bu yardımcı olur umarım!

Eğer xorher şey için kabul edilebilir ama çıkarım F(y)verilen xve F(x)o zaman sana bir ile yapabilirsiniz düşünmek tuz . Önce gizli bir tek yönlü işlev seçin. Örneğin S(s) = MD5(secret ^ s). O zaman F(x) = (s, S(s) ^ x)nerede srastgele seçilir. Bunu bir demet olarak yazdım, ancak iki parçayı bir tam sayıya birleştirebilirsiniz, örneğin F(x) = 10000 * s + S(s) ^ x. Şifre çözme, tuzu stekrar çıkarır ve kullanır F'(F(x)) = S(extract s) ^ (extract S(s)^x). Verildi xve F(x)görebiliyorsunuz s(biraz karıştırılmış olsa da) ve çıkarım yapabilirsiniz, S(s)ancak yfarklı bir rasgele tuza sahip başka bir kullanıcı tiçin kullanıcı bilerek F(x)bulamaz S(t).