c - 停留在 C 中的 Speck 解密算法

Question

我想在我的平台上使用 Speck 分组密码进行加密。 https://en.wikipedia.org/wiki/Speck_(cipher) 上提供了一些 C 语言代码，但它们不提供解密。

目前，我修改了代码以实现 Speck 64/128(64 位 block 和 128 位 key )并获得(假设)成功加密，现在我想再次解密它。 key 是硬编码的，这只是为了进行基准测试。

#include <stdint.h>

#define ROR(x, r) ((x >> r) | (x << (32 - r)))
#define ROL(x, r) ((x << r) | (x >> (32 - r)))
#define R(x, y, k) (x = ROR(x, 8), x += y, x ^= k, y = ROL(y, 3), y ^= x)
#define ROUNDS 27

void speckEncrypt(uint32_t pt[2], uint32_t ct[2], uint32_t K[2]) {
   uint32_t y = pt[0], x = pt[1], b = K[0], a = K[1];

   R(x, y, b);
   for (int i = 0; i < ROUNDS - 1; i++) {
      R(a, b, i);
      R(x, y, b);
   }

   ct[0] = y;
   ct[1] = x;
}

void speckDecrypt(uint32_t pt[2], uint32_t ct[2], uint32_t K[2]) {
}

static void speck(uint32_t pt[2]){

    uint32_t ct[2];

    uint32_t K[4] = {123456789,123456789,123456789,123456789};

    printf("Plaintext x: %lu", pt[0]);
    printf(", Plaintext y: %lu \n", pt[1]);

    printf("Get key schedule \n");

    speckEncrypt(pt, ct, K);

    printf("Encrypted  encr_x: %lu ",ct[0]);
    printf(", Encrypted  encr_y: %lu \n", ct[1]);

//  speckDecrypt(pt, ct, K);

//  printf("Decrypted x: %lu", pt[0]);
//  printf(", Decrypted y: %lu \n", pt[1]);
}

我没有成功实现 speckDecrypt。我尝试四处寻找其他解决方案，但始终失败(例如 https://www.multos.com/forums/viewthread/97 )。 我对加密没有经验，所以有人可以帮助我吗？

编辑:

我也对使用键扩展的 Java 实现做了同样的事情。 这个也可以加上吗？据我所知，Java 版本有效。

public void speck(int subm_x,int subm_y){
    byte n = 32;   // Word size
    byte m = 4;   // # of key words
    byte T = 27;   // Number of rounds
    int[] l;  // Used in the key generation
    int[] k;  // Stores subkeys
    int x;   // Encrypted x
    int y;   // Encrypted y
    byte alpha = 8; // Number of shifts, function of n
    byte beta = 3; // Number of shifts, function of n

    k = new int[T];
    l = new int[2*T];

    k[0] = 123456789; //faux random number. Max Int is 2,147,483,647
    k[1] = 123456789; //faux random number. Max Int is 2,147,483,647
    k[2] = 123456789; //faux random number. Max Int is 2,147,483,647
    k[3] = 123456789; //faux random number. Max Int is 2,147,483,647

    l[m-4] = 1123456789;
    l[m-3] = 1113456789;
    l[m-2] = 1111456789;

    x = subm_x;
    y = subm_y;

    /* *************** KEY EXTENSTION ***************** */
    for(int i = 0; i < T-1; i++) {
        l[i+m-1] = (k[i] + rotateRight(l[i], alpha)) ^ i;
        k[i+1] = rotateLeft(k[i], beta) ^ l[i+m-1]; 
    }
    /* *************** ENCRYPTION ********************* */
    for(int i = 0; i < T; i++) {
        x = (rotateRight(x, alpha) + y) ^ k[i];
        y = rotateLeft(y, beta) ^ x;
    }

    /* *************** DECRYPTION ********************* */         
    for(int i = T-1; i >= 0; i--) {
        y = rotateRight(x ^ y, beta);
        x = rotateLeft((x ^ k[i]) - y, alpha);
    }
    }

目的是将它们相互作为基准。

Answer 1

我在 https://github.com/madmo/speck/blob/master/speck.c 上找到了可靠的实现 并使用非组合版本(不确定差异)。

这是有效的，希望可以帮助其他人!

根据要求，我的实现(作为 Contiki 进程):

#include <stdint.h>
#define SPECK_TYPE uint32_t
#define SPECK_ROUNDS 27
#define SPECK_KEY_LEN 4

#define ROR(x, r) ((x >> r) | (x << ((sizeof(SPECK_TYPE) * 8) - r)))
#define ROL(x, r) ((x << r) | (x >> ((sizeof(SPECK_TYPE) * 8) - r)))

#ifdef SPECK_32_64
#define R(x, y, k) (x = ROR(x, 7), x += y, x ^= k, y = ROL(y, 2), y ^= x)
#define RR(x, y, k) (y ^= x, y = ROR(y, 2), x ^= k, x -= y, x = ROL(x, 7))
#else
#define R(x, y, k) (x = ROR(x, 8), x += y, x ^= k, y = ROL(y, 3), y ^= x)
#define RR(x, y, k) (y ^= x, y = ROR(y, 3), x ^= k, x -= y, x = ROL(x, 8))
#endif

void speck_expand(SPECK_TYPE const K[static SPECK_KEY_LEN], SPECK_TYPE S[static SPECK_ROUNDS])
{
    SPECK_TYPE i, b = K[0];
    SPECK_TYPE a[SPECK_KEY_LEN - 1];

    for (i = 0; i < (SPECK_KEY_LEN - 1); i++)
    {
        a[i] = K[i + 1];
    }
    S[0] = b;
    for (i = 0; i < SPECK_ROUNDS - 1; i++) {
        R(a[i % (SPECK_KEY_LEN - 1)], b, i);
        S[i + 1] = b;
    }
}

void speck_encrypt(SPECK_TYPE const pt[static 2], SPECK_TYPE ct[static 2], SPECK_TYPE const K[static SPECK_ROUNDS])
{
    SPECK_TYPE i;
    ct[0]=pt[0]; ct[1]=pt[1];

    for(i = 0; i < SPECK_ROUNDS; i++){
        R(ct[1], ct[0], K[i]);
    }
}

void speck_decrypt(SPECK_TYPE const ct[static 2], SPECK_TYPE pt[static 2], SPECK_TYPE const K[static SPECK_ROUNDS])
{
    SPECK_TYPE i;
    pt[0]=ct[0]; pt[1]=ct[1];

    for(i = 0; i < SPECK_ROUNDS; i++){
        RR(pt[1], pt[0], K[(SPECK_ROUNDS - 1) - i]);
    }
}

PROCESS_THREAD(eval_crypto_process, ev, data)
{
    PROCESS_BEGIN();
    printf("eval_crypto_process\n");

    while(1){
        printf("Waiting.\n");

        static struct etimer timer;
        etimer_set(&timer, 5*CLOCK_CONF_SECOND);
        PROCESS_WAIT_UNTIL(etimer_expired(&timer));
        printf("Starting crypto.\n");

        PORTB ^= _BV(PB5);
        PORTB ^= _BV(PB6);

        uint32_t plain[2] = {987654321,987654321};
        uint32_t key[4] = {123456789, 123456789, 123456789, 123456789};

        SPECK_TYPE buffer[2] = {0};
        SPECK_TYPE enc[2] = {0};

        SPECK_TYPE exp[SPECK_ROUNDS];

        speck_expand(key, exp);

//      printf("Plaintext x: %lu", plain[0]);
//      printf(", Plaintext y: %lu \n", plain[1]);

        speck_encrypt(plain, enc, exp);

//      printf("Encrypted  encr_x: %lu ",enc[0]);
//      printf(", Encrypted  encr_y: %lu \n", enc[1]);

        speck_decrypt(enc, buffer, exp);

//      printf("Decrypted x: %lu", buffer[0]);
//      printf(", Decrypted y: %lu \n", buffer[1]);

        PORTB ^= _BV(PB5);
        PORTB ^= _BV(PB6);

        printf("finished crypto.\n");
    }

    PROCESS_END();
}