Theo tinh thần của Cuộc thi C Underhanded , tôi đang bắt đầu Cuộc thi Code Underhanded. Mục tiêu của cuộc thi này là đơn giản thực hiện một số mã, trong khi khéo léo che giấu một lỗi bất chính bên trong nó.

Cuộc thi

Bạn là một nốt ruồi bí mật của Nga làm việc trong bộ phận CNTT của một cơ quan gián điệp Mỹ. Sếp người Mỹ của bạn vừa yêu cầu bạn thực hiện thuật toán băm mật khẩu để sử dụng để mã hóa các tin nhắn bí mật.

Sếp của bạn muốn bạn thực hiện chức năng sau:

f: String -> byte[16]

chuyển đổi mật khẩu thành số lượng 16 byte phù hợp để sử dụng làm khóa AES. Sếp của bạn muốn có một chức năng bảo mật, trong ngữ cảnh này có nghĩa là các chuỗi mật khẩu khác nhau sẽ tạo ra các kết quả khác nhau với xác suất áp đảo. Ví dụ, trả về băm md5 của đầu vào sẽ là một cách thực hiện đơn giản f.

Tất nhiên, ông chủ thực sự của bạn trong cơ quan gián điệp Nga sẽ muốn bạn lật đổ quá trình này. Nhiệm vụ của bạn là triển khai fsao cho người Nga có thể giải mã tất cả các tin nhắn bí mật được mã hóa bằng các khóa được trả về f.

Để làm như vậy, bạn phải thực hiện fsao cho nó chỉ trả về một tập hợp con nhỏ trong 2 ^ 128 đầu ra có thể. Cụ thể, bạn fphải trả lại tối đa 2 ^ 16 kết quả khác nhau để người Nga có thể thực hiện tìm kiếm dễ dàng cho khóa chính xác cho mỗi tin nhắn được mã hóa mà họ muốn giải mã.

Tuy nhiên, hãy nhớ rằng gián điệp mang án tử hình. Để không bị bắt, chức năng của bạn fphải tạo ra ít nhất 2 ^ 8 kết quả khác nhau, do đó việc kiểm tra một cách khó hiểu về một vài kết quả đầu ra fkhông có khả năng tiết lộ một bản sao. Và quan trọng nhất, mã bạn giới thiệu để giới hạn phạm vi fphải trông vô tình, không cố ý. Nếu bạn từng bị lôi vào phòng xử án, phải có một số nghi ngờ hợp lý về việc bạn đã đưa ra lỗi cố ý hay vô tình.

Đánh giá

Tôi và hai người khác tôi tuyển dụng sẽ đánh giá các mục (gửi email cho tôi nếu bạn muốn đánh giá). Tôi đang cung cấp 200 tiền thưởng danh tiếng cho mục thắng. Đệ trình phải được tải lên trước ngày 1 tháng 5.

Đánh giá sẽ tính đến các tiêu chí sau:

• Có ftuân thủ thông số kỹ thuật không, tức là nó có tạo ra từ 2 ^ 8 đến 2 ^ 16 đầu ra có thể. Đừng cảm thấy đây là những giới hạn cứng, nhưng chúng tôi sẽ trừ điểm nếu bạn ở quá xa phạm vi.
• Là lỗi có thể là kết quả của một lỗi vô ý?
• Làm đầu ra của fnhìn ngẫu nhiên?
• Việc thực hiện của bạn càng ngắn fthì càng tốt.
• Việc thực hiện của bạn càng rõ ràng fthì càng tốt.

Ghi chú

Bạn có thể sử dụng bất kỳ ngôn ngữ để thực hiện mã của bạn. Bạn đang cố gắng che giấu một lỗi trong tầm nhìn rõ ràng, vì vậy mã bị xáo trộn không được đề xuất.

Bạn có thể muốn xem qua một số người chiến thắng trong cuộc thi Underhanded C trước đây để cảm nhận về những gì làm cho một bài nộp tốt.

Chuỗi đầu vào sẽ có thể in ascii (bao gồm 32 đến 126, bao gồm). Bạn có thể giả sử độ dài tối đa hợp lý nếu bạn muốn.

C

2 ^ 16 đầu ra có thể (hoặc gấp 2 ^ 8 lần số ký tự được sử dụng).
Sử dụng triển khai MD5 của Linux, đó là, AFAIK, tốt. Nhưng điều này cho cùng một hàm băm, ví dụ, cho "40" và "42".
EDIT: Đổi tên bcopyđể memcpy(thông số hoán đổi tất nhiên).
EDIT: Chuyển đổi từ chương trình sang chức năng, để đáp ứng yêu cầu tốt hơn.

#include <string.h>
#include <openssl/md5.h>

void f(const unsigned char *input, unsigned char output[16]) {

    /* Put the input in a 32-byte buffer, padded with zeros. */
    unsigned char workbuf[32] = {0};
    strncpy(workbuf, input, sizeof(workbuf));

    unsigned char res[MD5_DIGEST_LENGTH];
    MD5(workbuf, sizeof(workbuf), res);

    /* NOTE: MD5 has known weaknesses, so using it isn't 100% secure.
     * To compensate, prefix the input buffer with its own MD5, and hash again. */
    memcpy(workbuf+1, workbuf, sizeof(workbuf)-1);
    workbuf[0] = res[0];
    MD5(workbuf, sizeof(workbuf), res);

    /* Copy the result to the output buffer */
    memcpy(output, res, 16);
}

/* Some operating systems don't have memcpy(), so include a simple implementation */
void *
memcpy(void *_dest, const void *_src, size_t n)
{
    const unsigned char *src = _src;
    unsigned char *dest = _dest;
    while (n--) *dest++ = *src++;
    return _dest;
}

C

Đây có thể không phải là mục tham gia cuộc thi hào nhoáng nhất, nhưng tôi nghĩ sau đây là loại hàm băm có thể được tạo bởi bất kỳ lập trình viên nào quá thông minh vì lợi ích của họ, với một ý tưởng mơ hồ về loại hoạt động bạn thấy trong các hàm băm:

#include <stdio.h>
#include <string.h>
#include <stdint.h>

void hash(const char* s, uint8_t* r, size_t n)
{
     uint32_t h = 123456789UL;
     for (size_t i = 0; i < n; i++) {
          for (const char* p = s; *p; p++) {
               h = h * 33 + *p;
          }
          *r++ = (h >> 3) & 0xff;
          h = h ^ 987654321UL;
     }
}

int main()
{
     size_t n = 1024;
     char s[n];
     size_t m = 16;
     uint8_t b[m];
     while (fgets(s, n, stdin)) {
          hash(s, b, m);
          for (size_t i = 0; i < m; ++i)
               printf("%02x", b[i]);
          printf("\n");
     }
}

Trong thực tế, hàm băm có thể trả về không quá L * 2048 kết quả khác nhau, trong đó L là số lượng độ dài chuỗi đầu vào khác nhau có thể xảy ra. Trong thực tế, tôi đã thử nghiệm mã trên 1,85 triệu dòng đầu vào duy nhất từ ​​các trang thủ công và tài liệu html trên máy tính xách tay của tôi và chỉ nhận được 85428 băm khác nhau.

Scala:

// smaller values for more easy tests:
val len = 16
// make a 16 bytes fingerprint
def to16Bytes (l: BigInt, pos: Int=len) : List[Byte] = 
  if (pos == 1) List (l.toByte) else (l % 256L).toByte :: to16Bytes (l / 256L, pos-1)
/** if number isn't prime, take next */
def nextProbPrime (l: BigInt) : BigInt = 
  if (l.isProbablePrime (9)) l else nextProbPrime (l + 1)
/** Take every input, shift and add, but take primes */
def codify (s: String): BigInt = 
  (BigInt (17) /: s) ((a, b) => nextProbPrime (a * BigInt (257) + b))
/** very, very short Strings - less than 14 bytes - have to be filled, to obscure them a bit: */
def f (s: String) : Array [Byte] = {
  val filled = (if (s.size < 14) s + "secret" + s else s)
  to16Bytes (codify (filled + filled.reverse)).toArray.map (l => nextProbPrime (l).toByte) 
}

Kiểm tra, nếu kết quả không giống với đầu vào tương tự:

val samples = List ("a", "aa", "b", "", "longer example", "This is a foolish, fishy test") 

samples.map (f) 

 List[Array[Byte]] = List(
Array (-41, -113, -79, 127, 29, 127, 31, 67, -19, 83, -73, -31, -101, -113, 97, -113), 
Array (-19, 7, -43, 89, -97, -113, 47, -53, -113, -127, -31, -113, -67, -23, 127, 127), 
Array (-41, -113, -79, 127, 29, 127, 31, 67, -19, 83, -73, -31, -101, -113, 97, -113), 
Array (37, -19, -7, 67, -83, 89, 59, -11, -23, -47, 97, 83, 19, 2, 2, 2), 
Array (79, 101, -47, -103, 47, -13, 29, -37, -83, -3, -37, 59, 127, 97, -43, -43), 
Array (37, 53, -43, -73, -67, 5, 11, -89, -37, -103, 107, 97, 37, -71, 59, 67))

Lỗi là chỉ sử dụng các số nguyên tố cho mã hóa. Thay vì

scala> math.pow (256, 16)
res5: Double = 3.4028236692093846E38

giá trị, chúng tôi kết thúc với

scala> math.pow (54, 16)
res6: Double = 5.227573613485917E27

vì có 54 số nguyên tố dưới 256.