Làm xáo trộn một ID


85

Tôi đang tìm cách mã hóa / làm xáo trộn một số nguyên ID thành một số nguyên khác. Chính xác hơn, tôi cần một chức năng int F(int x), để

  • x <-> F (x) là tương ứng 1-1 (nếu x! = y, F (x)! = F (y))
  • cho trước F (x), thật dễ dàng để tìm ra x - vì vậy F không phải là một hàm băm
  • với x và F (x) rất khó / không thể tìm ra F (y), một cái gì đó như x ^ 0x1234sẽ không hoạt động

Để rõ ràng, tôi không tìm kiếm một giải pháp mã hóa mạnh mà chỉ là sự xáo trộn. Hãy tưởng tượng một ứng dụng web có các url như example.com/profile/1, example.com/profile/2v.v. Bản thân các hồ sơ không phải là bí mật, nhưng tôi muốn ngăn những người xem thường lần lượt xem / tìm nạp tất cả các hồ sơ, vì vậy tôi muốn ẩn chúng đằng sau một cái gì đó như thế example.com/profile/23423, example.com/profile/80980234v.v. Các mã thông báo được lưu trữ trong cơ sở dữ liệu có thể thực hiện công việc khá dễ dàng, tôi rất tò mò nếu có một số phép toán đơn giản cho việc này.

Một yêu cầu quan trọng mà tôi không rõ là kết quả phải trông "ngẫu nhiên", tức là, được đưa ra theo một chuỗi x,x+1,...,x+n, F(x),F(x+1)...F(x+n)không nên tạo thành một tiến trình của bất kỳ loại nào.


Int F (int x) là một yêu cầu hay nó có thể là int [2] F (int x)?
Eugen Rieck

@Eugen Rieck, lý tưởng là tôi muốn x và F (x) nằm trong dãy số
georg

@ toon81, vâng, chức năng sẽ được giữ bí mật
georg

vì bạn đã nói rằng bạn muốn đi mà không có mã thông báo, điều đó có nghĩa là bạn muốn tránh bất kỳ loại bảng tra cứu nào?
Daniel Mošmondor

16
Trời đất, câu hỏi này được phát biểu một cách hoàn hảo và chính xác là những gì tôi đang tìm kiếm. Công việc tốt.
Snekse

Câu trả lời:


39

Làm xáo trộn nó bằng một số kết hợp của 2 hoặc 3 phương pháp đơn giản:

  • XOR
  • xáo trộn các bit riêng lẻ
  • chuyển đổi sang biểu diễn mô-đun (D.Knuth, Tập 2, Chương 4.3.2)
  • chọn 32 (hoặc 64) tập con bit chồng chéo và bit XOR trong mỗi tập con (bit chẵn lẻ của tập con)
  • biểu diễn nó trong hệ thống số có độ dài thay đổi và xáo trộn các chữ số
  • chọn một cặp số nguyên lẻ xylà phép nhân nghịch đảo của nhau (modulo 2 32 ), sau đó nhân xvới để xáo trộn và nhân yvới để khôi phục, tất cả các phép nhân đều là modulo 2 32 (nguồn: "Một cách sử dụng thực tế của phép nhân nghịch đảo" của Eric Lippert )

Phương thức hệ thống số có độ dài thay đổi không tuân theo yêu cầu "lũy tiến" của riêng bạn. Nó luôn tạo ra các cấp số cộng ngắn. Nhưng khi kết hợp với một số phương pháp khác lại cho kết quả tốt.

Điều này cũng đúng với phương pháp biểu diễn mô-đun.

Đây là ví dụ về mã C ++ cho 3 phương pháp này. Ví dụ về các bit xáo trộn có thể sử dụng một số mặt nạ và khoảng cách khác nhau để khó dự đoán hơn. 2 ví dụ khác là tốt cho số lượng nhỏ (chỉ để cung cấp cho ý tưởng). Chúng phải được mở rộng để làm xáo trộn tất cả các giá trị số nguyên một cách chính xác.

// *** 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

Cảm ơn về câu trả lời của bạn. Nếu bạn có thể cung cấp một số ví dụ về mã giả, nếu sẽ rất tuyệt.
georg 19/12/11

3
@ thg435 Tôi đã sử dụng C ++ thay vì mã giả. Không muốn đưa ra các ví dụ chưa được kiểm tra.
Evgeny Kluev 19/12/11

1
Khi tôi thử mã cơ sở của hệ thống số ở trên với x = 99, tôi nhận được z = 44.
Harvey

@Harvey: để có được bộ xáo trộn có thể đảo ngược, sản phẩm của tất cả các cơ sở phải lớn hơn số để làm xáo trộn. Trong ví dụ này 3 * 4 * 5 = 60, vì vậy bất kỳ số nào lớn hơn (như 99) sẽ không nhất thiết được khôi phục về cùng một giá trị.
Evgeny Kluev

1
@Harvey: Ngoài ra, có thể lấy tích của tất cả các cơ sở nhỏ hơn nhưng rất gần với 2 ^ 32, và sau đó xáo trộn các giá trị còn lại bằng một bảng nhỏ. Trong trường hợp này, mọi thứ vẫn ở dạng số 32-bit.
Evgeny Kluev

8

Bạn muốn chuyển đổi có thể đảo ngược, và không hiển nhiên. Điều đó nghe giống như một mã hóa lấy một số trong một phạm vi nhất định và tạo ra một số khác trong cùng một phạm vi. Nếu phạm vi của bạn là số 64 bit, thì hãy sử dụng DES. Nếu phạm vi của bạn là số 128 bit thì hãy sử dụng AES. Nếu bạn muốn một phạm vi khác, thì đặt cược tốt nhất của bạn có lẽ là mật mã Hasty Pudding , được thiết kế để đối phó với các kích thước khối khác nhau và với các phạm vi số không vừa khít với một khối, chẳng hạn như 100.000 đến 999.999.


Thứ thú vị, nhưng nó có thể là một chút khó khăn để hỏi ai đó để thực hiện một thuật toán mã hóa 1) chưa được thử nghiệm tốt và 2) đã không được thử nghiệm tốt vì nó là như vậy khó hiểu :)
Maarten Bodewes

Cảm ơn! Tôi đang cố gắng giữ cho nó càng đơn giản càng tốt.
georg 19/12/11

Nếu bạn không thể tìm thấy cách triển khai Hasty Pudding (bạn chỉ cần một trong các kích thước được phép) thì bạn có thể dễ dàng triển khai mật mã Feistel 4 vòng đơn giản ( en.wikipedia.org/wiki/Feistel_cipher ) ở kích thước khối chẵn. Chỉ cần tiếp tục mã hóa cho đến khi đầu ra nằm trong phạm vi chính xác, như với Hasty Pudding. Không an toàn, nhưng đủ để làm xáo trộn.
rossum 19/12/11

NSA hiện đã phát hành mật mã Speck bao gồm các phiên bản bao gồm các kích thước khối 32 bit và 48 bit. Điều đó cũng có thể hữu ích để làm xáo trộn các số với các kích thước đó. Đặc biệt, phiên bản 32-bit có thể hữu ích.
rossum

5

Obfuscation không thực sự đủ về mặt bảo mật.

Tuy nhiên, nếu bạn đang cố gắng ngăn cản người xem bình thường, tôi khuyên bạn nên kết hợp hai phương pháp:

  • Khóa riêng tư mà bạn kết hợp với id bằng cách kết hợp chúng lại với nhau
  • Xoay các bit theo một số lượng nhất định cả trước và sau khi khóa được áp dụng

Đây là một ví dụ (sử dụng mã giả):

  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

Tôi chưa thử nghiệm nó, nhưng tôi nghĩ rằng điều này có thể đảo ngược, phải nhanh chóng và không quá dễ dàng để đưa ra phương pháp.


Ngoài ra còn có thêm một mod liên tục 2 ^ 32 (vì vòng quay bit của bạn khiến tôi nhớ đến rot13, chức năng đảo ngược tầm thường yêu thích của mọi người).
ccoakley

Đó thực sự chỉ là return x XOR rotr(31415927, 5)mặc dù, phải không? Xor cuối cùng hoàn tác xor đầu tiên, và quay xor hoàn tác khác nhau .. tất nhiên bất kỳ chuỗi hoạt động thuận nghịch nào cũng có thể đảo ngược, vì vậy nó thỏa mãn điều kiện đó.
harold

Tôi đã chạy một vài thử nghiệm ngắn và hài lòng với kết quả như mong đợi. Như ccoakley đã đề cập, rot13 có thể được sử dụng thay cho rot5, bất kỳ vòng quay nào cũng sẽ hoạt động (báo trước: 0> rot> integer-size) và có thể được coi là một khóa khác. Có những thứ khác bạn có thể ném vào đây, như modulus như anh ấy gợi ý, và miễn là chúng có thể đảo ngược như harold đã đề cập.
IAmNaN

1
Xin lỗi, nhưng @harold hầu như đúng - toàn bộ chức năng của bạn tương đương với x = x XOR F(0), hoặc x = x XOR 3087989491, hoặc x = x XOR rotr(31415927, 5). Các xors đầu tiên và cuối cùng của bạn phủ định lẫn nhau, vì vậy tất cả những gì bạn đang làm là xoạc đầu vào được dịch chuyển bit với khóa - hoặc tương đương, phân chia đầu vào bằng khóa được dịch chuyển bit. Lưu ý rằng điều này đúng ngay cả khi bạn đã sử dụng các phím khác nhau cho từng giai đoạn - tất cả các phím có thể được gộp thành một khóa duy nhất có thể được phân loại với bản rõ.
Nick Johnson

2
Nó thậm chí còn tệ hơn, khá dễ dàng để chứng minh rằng bất kỳ chuỗi quay nào bằng một độ lệch không đổi và xors với một hằng số có thể được cô đọng lại thành chỉ một vòng và chỉ một xor. Có thể kết hợp hai vòng xoay sau khi vị trí khác nhau (thêm phần bù của chúng), hai phần xor sau phần tử khác có thể được kết hợp (xor với xor của hai hằng số) và một cặp xor / rot có thể được hoán đổi thành rot / xor bằng cách áp dụng cùng một vòng quay cho hằng số trong xor.
harold


3

Tôi đã viết một số mã JS bằng một số ý tưởng trong chuỗi này:

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,
);

Nó tạo ra một số kết quả tốt đẹp như:

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'

Thử nghiệm với:

  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));
   }

XOR1XOR2chỉ là các số ngẫu nhiên từ 0 đến MAX. MAX2**32-1; bạn nên đặt giá trị này thành bất kỳ giá trị nào bạn cho rằng ID cao nhất của mình sẽ là.

COPRIMElà một số có cùng chuẩn với w / MAX. Tôi nghĩ rằng bản thân các số nguyên tố là nguyên tố với mọi số khác (ngoại trừ bội số của chúng).

INVERSElà một trong những khó khăn để tìm ra. Những bài đăng trên blog này không đưa ra câu trả lời thẳng thắn, nhưng WolframAlpha có thể tìm ra câu trả lời cho bạn . Về cơ bản, chỉ cần giải phương trình (COPRIME * x) % MAX = 1cho x.

Các buildchức năng là điều mà tôi tạo ra để làm cho nó dễ dàng hơn để tạo ra những đường ống dẫn mã hóa / giải mã. Bạn có thể cung cấp cho nó bao nhiêu thao tác tùy thích theo [encode, decode]từng cặp. Các chức năng này phải bằng nhau và trái dấu. Các XORchức năng là những lời khen ngợi riêng của họ, vì vậy bạn không cần một cặp ở đó.


Đây là một niềm vui sự co hồi :

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

(giả sử số nguyên 24 bit - chỉ cần thay đổi các số cho bất kỳ kích thước nào khác)


1
mát mẻ, cảm ơn vì đã chia sẻ! BTW "32n" là gì? Chưa bao giờ thấy điều này trước đây.
georg

1
nlà một hậu tố số cho BigInts . Đó là một tính năng JS mới cho phép bạn xử lý những con số thực sự lớn. Tôi cần sử dụng nó vì tôi đang nhân với các số thực sự lớn, điều này có thể khiến một trong các giá trị trung gian tạm thời vượt quá Number.MAX_SAFE_INTEGERvà mất độ chính xác.
mpen

2

Làm bất cứ điều gì với các bit của ID sẽ không phá hủy chúng. Ví dụ:

  • xoay giá trị
  • sử dụng tra cứu để thay thế các phần nhất định của giá trị
  • xor với một số giá trị
  • hoán đổi bit
  • hoán đổi byte
  • phản chiếu toàn bộ giá trị
  • phản chiếu một phần giá trị
  • ... sử dụng trí tưởng tượng của bạn

Để giải mã, hãy làm tất cả điều đó theo thứ tự ngược lại.

Tạo một chương trình sẽ 'mã hóa' một số giá trị thú vị cho bạn và đặt chúng vào một bảng mà bạn có thể kiểm tra. Có cùng chương trình KIỂM TRA quy trình mã hóa / giải mã của bạn VỚI tất cả các bộ giá trị mà bạn muốn có trong hệ thống của mình.

Thêm những thứ trong danh sách trên vào quy trình cho đến khi các con số của bạn trông phù hợp với bạn.

Đối với bất kỳ điều gì khác, hãy lấy một bản sao của Cuốn sách .


Những gì bạn mô tả là các khối xây dựng của mật mã khối. Sẽ có ý nghĩa hơn khi sử dụng cái hiện có hơn là phát minh ra cái của riêng bạn.
Nick Johnson

@NickJohnson Tôi biết điều đó, bạn có nhấp vào liên kết ở dòng cuối cùng của bài đăng của tôi không?
Daniel Mošmondor

Tôi đã không thể kết hợp rotl / xor lại với nhau để đưa ra kết quả trông đủ "ngẫu nhiên" (xem bản cập nhật). Bất kỳ gợi ý?
georg

@ DanielMošmondor Tôi biết bạn đang liên kết đến cái gì - nhưng điều đó không thay đổi thực tế là ban đầu bạn đề xuất anh ấy tự xây dựng thứ gì đó, khi chỉ sử dụng một thứ hiện có sẽ có ý nghĩa hơn nhiều?
Nick Johnson

@NickJohnson rõ ràng là OP không muốn sử dụng tiền điện tử hiện có, vì anh ấy muốn học hoặc không muốn học các API mới. Tôi hoàn toàn có thể liên quan đến điều đó.
Daniel Mošmondor

2

Tôi đã viết một bài báo về hoán vị an toàn với mật mã khối , phải đáp ứng các yêu cầu của bạn như đã nêu.

Tuy nhiên, tôi đề nghị rằng nếu bạn muốn các số nhận dạng khó đoán, bạn chỉ nên sử dụng chúng ngay từ đầu: tạo UUID và sử dụng chúng làm khóa chính cho hồ sơ của bạn ngay từ đầu - không cần thiết phải có để chuyển đổi sang và từ một ID 'thực'.


2
@ thg435 Nếu bạn quan tâm đến cách tiếp cận này, một cụm từ tìm kiếm hữu ích là "Mã hóa bảo tồn định dạng". Trang wikipedia bao gồm bài báo Black / Rogaway được đề cập trong bài báo của Nick, cũng như những phát triển gần đây hơn. Tôi đã sử dụng thành công FPE cho một cái gì đó tương tự như những gì bạn đang làm; mặc dù trong trường hợp của tôi, tôi đã thêm một vài bit bên cạnh id mà tôi đã sử dụng để kiểm tra tính hợp lệ nhẹ.
Paul Du Bois

1

Không chắc bạn cần nó "khó" đến mức nào, tốc độ như thế nào, hoặc sử dụng ít bộ nhớ như thế nào. Nếu bạn không có ràng buộc về bộ nhớ, bạn có thể tạo danh sách tất cả các số nguyên, xáo trộn chúng và sử dụng danh sách đó làm ánh xạ. Tuy nhiên, ngay cả đối với một số nguyên 4 byte, bạn sẽ cần rất nhiều bộ nhớ.

Tuy nhiên, điều này có thể được làm nhỏ hơn để thay vì ánh xạ tất cả các số nguyên, bạn sẽ chỉ ánh xạ 2 (hoặc trường hợp xấu nhất là 1) byte và áp dụng điều này cho từng nhóm trong số nguyên. Vì vậy, sử dụng 2 byte một số nguyên sẽ là (group1) (group2) bạn sẽ ánh xạ từng nhóm thông qua bản đồ ngẫu nhiên. Nhưng điều đó có nghĩa là nếu bạn chỉ thay đổi nhóm2 thì ánh xạ cho nhóm1 sẽ giữ nguyên. Điều này có thể được "sửa chữa" bằng cách ánh xạ các bit khác nhau cho mỗi nhóm.

Vì vậy, * (group2) có thể là (bit 14,12,10,8,6,4,2,0) vì vậy, việc thêm 1 sẽ thay đổi cả nhóm1nhóm2 .

Tuy nhiên, đây chỉ là bảo mật bằng cách che giấu, bất kỳ ai có thể đưa các số vào hàm của bạn (ngay cả khi bạn giữ bí mật về hàm) đều có thể dễ dàng tìm ra.


Tùy thuộc vào các ràng buộc của hệ thống, điều này có thể sẽ không hoạt động, bởi vì nếu bạn có thể đảo ngược F (x) trở lại x thì bạn phải có sẵn hoán vị, từ đó bạn có thể dễ dàng tính F (y) cho bất kỳ y tùy ý.
templatetypedef.

@templatetypedef Như tôi đã nói, đây chỉ là bảo mật bằng cách che giấu. Hoán vị sẽ phải được biết đến, nhưng bạn có thể xem hoán vị là "chìa khóa". Vấn đề lớn nhất ở đây là OP dường như muốn có thể mã hóa tất cả các thư trong một tập hợp (một tập hợp nhỏ) trong đó thư được mã hóa phải nằm trong cùng một tập hợp và điều này phải hợp lệ cho tất cả các thư trong tập hợp.
Roger Lindsjö

Cảm ơn. Tôi đang cố gắng tránh bất kỳ bảng tra cứu nào.
georg 19/12/11

1

Tạo một khóa đối xứng riêng để sử dụng trong ứng dụng của bạn và mã hóa số nguyên của bạn với nó. Điều này sẽ đáp ứng cả ba yêu cầu, bao gồm cả yêu cầu khó nhất thứ 3: một người sẽ cần phải đoán khóa của bạn để phá vỡ kế hoạch của bạn.


thg435 đã yêu cầu nhập số nguyên thành số nguyên (và theo như tôi hiểu thì nó sẽ hoạt động với tất cả các số nguyên). Bạn có thể đề xuất một thuật toán khóa riêng sẽ có các thuộc tính này không?
Roger Lindsjö

1

Những gì bạn đang mô tả ở đây dường như trái ngược với một hàm một chiều: nó dễ dàng để đảo ngược nhưng cực kỳ khó áp dụng. Một tùy chọn sẽ là sử dụng thuật toán mã hóa khóa công khai tiêu chuẩn, sẵn có trong đó bạn sửa khóa công khai (bí mật, được chọn ngẫu nhiên) mà bạn giữ bí mật và khóa riêng tư mà bạn chia sẻ với mọi người. Bằng cách đó, hàm F (x) của bạn sẽ là mã hóa của x bằng cách sử dụng khóa công khai. Sau đó, bạn có thể dễ dàng giải mã F (x) trở lại x bằng cách sử dụng khóa giải mã riêng. Lưu ý rằng các vai trò của khóa công khai và khóa cá nhân được đảo ngược ở đây - bạn cung cấp khóa riêng tư cho mọi người để họ có thể giải mã chức năng, nhưng giữ bí mật khóa công khai trên máy chủ của bạn. Theo cách đó:

  1. Hàm là một lưỡng phân, vì vậy nó có thể nghịch đảo.
  2. Cho F (x), x có thể tính được.
  3. Với x và F (x), rất khó để tính F (y) từ y, vì nếu không có khóa công khai (giả sử bạn sử dụng một lược đồ mã hóa mạnh về mặt mật mã) thì không có cách nào khả thi để mã hóa dữ liệu, ngay cả khi riêng tư khóa giải mã được biết đến.

Điều này có nhiều lợi thế. Trước tiên, bạn có thể yên tâm rằng hệ thống tiền điện tử là an toàn, vì nếu bạn sử dụng một thuật toán được thiết lập tốt như RSA thì bạn không cần phải lo lắng về sự mất an toàn ngẫu nhiên. Thứ hai, đã có các thư viện sẵn có để làm việc này, vì vậy bạn không cần phải viết mã nhiều và có thể miễn nhiễm với các cuộc tấn công kênh phụ. Cuối cùng, bạn có thể làm cho bất kỳ ai có thể đi và đảo ngược F (x) mà không ai thực sự có thể tính F (x).

Một chi tiết - bạn chắc chắn không nên chỉ sử dụng kiểu int tiêu chuẩn ở đây. Ngay cả với các số nguyên 64 bit, có rất ít sự kết hợp có thể xảy ra mà kẻ tấn công có thể thử đảo ngược mọi thứ cho đến khi họ tìm thấy mã hóa F (y) cho một số y ngay cả khi họ không có khóa. Tôi khuyên bạn nên sử dụng một thứ gì đó như giá trị 512-bit, vì ngay cả một cuộc tấn công khoa học viễn tưởng cũng không thể thực hiện được điều này.

Hi vọng điêu nay co ich!


Nhưng thg435 dường như đang yêu cầu mã hóa có thể mã hóa một tập hợp nhỏ các tin nhắn (tin nhắn 4 byte) vào cùng một tập tin nhắn và mã hóa sẽ hoạt động cho tất cả các tin nhắn.
Roger Lindsjö

Cảm ơn về câu trả lời của bạn. Sử dụng một khung mã hóa toàn diện có lẽ là cách tốt nhất để làm điều đó, nhưng hơi quá "nặng" so với nhu cầu của tôi.
georg

1

Nếu xorcó thể chấp nhận được cho mọi thứ nhưng suy ra đã F(y)cho xF(x)sau đó tôi nghĩ bạn có thể làm điều đó với một muối . Đầu tiên hãy chọn một chức năng một chiều bí mật. Ví dụ S(s) = MD5(secret ^ s). Sau đó, F(x) = (s, S(s) ^ x)nơi sđược chọn ngẫu nhiên. Tôi đã viết rằng như một tuple nhưng bạn có thể kết hợp hai phần vào một số nguyên, ví dụ F(x) = 10000 * s + S(s) ^ x. Giải mã sẽ chiết xuất muối smột lần nữa và sử dụng F'(F(x)) = S(extract s) ^ (extract S(s)^x). Đưa ra xF(x)bạn có thể thấy s(mặc dù nó hơi khó hiểu) và bạn có thể suy ra S(s)nhưng đối với một số người dùng khác yvới một muối ngẫu nhiên khác tmà người dùng biết F(x)không thể tìm thấy S(t).


Cảm ơn, nhưng điều này trông không đủ ngẫu nhiên đối với tôi (xem bản cập nhật)
georg

Muối được chọn ngẫu nhiên và băm S(s)cũng sẽ trông ngẫu nhiên, do đó F(x)sẽ không có bất kỳ loại tiến trình nào cả.
Ben Jackson
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.