求给定异或密码反馈模式解密函数对应的加密逆函数实现方法

我有一个用于解密的函数，看起来是某种密码反馈模式的实现。

该函数逻辑如下：数组的第0个元素与自身左移0xB位的结果做异或运算，之后所有数组元素左移：

• 第1个元素移到第0位
• 第2个元素移到第1位
• 第3个元素移到第2位

再经过若干异或运算后得到的结果成为数组新的第4个元素，循环执行以上步骤。

解密函数代码如下：

uint Some_function(uint *Array)                             // *Array为指向4个uint元素数组的指针
    {
      uint Temp_1;
      uint Temp_2;
      
      Temp_1 = *Array ^ *Array << 0xb;                          // Temp_1 = Array[0] 异或 Array[0]左移0xB位（乘以0x800）
      *Array = Array[1];                                        // Array[1]赋值给Array[0]
      Array[1] = Array[2];                                      // Array[2]赋值给Array[1]
      Temp_2 = Array[3];                                        // 将Array[3]加载到Temp_2
      Array[2] = Temp_2;                                        // Array[3]赋值给Array[2]
      Temp_1 = Temp_2 ^ Temp_2 >> 0x13 ^ Temp_1 ^ Temp_1 >> 8;  // Temp_1 = Temp_2 异或 (Temp_2右移0x13位) 异或 Temp_1 异或 (Temp_1右移8位)
      Array[3] = Temp_1;                                        // Temp_1赋值给Array[3]
      return Temp_1;
    }

该解密函数运行正常，但我不清楚如何实现对应的加密功能。我已知加密用的IV初始值如下：

array[] = {0x5E9094CA, 0xB2E34CBD, 0xF9ED0B7C, 0x577C17C1}

执行第一步解密后数组变为：

array[] = {0x10BF5970, 0x5E9094CA, 0xB2E34CBD, 0xF9ED0B7C}  

我猜测加密过程需要先对Array[3]做处理，再执行移位操作：

Array[2]移到Array[3]
Array[1]移到Array[2]
Array[0]移到Array[1]

再通过Array[3]和Array[2]或Array[1]的运算结果赋值给Array[0]，但我始终无法写出正确的逆函数实现。我是初学者，能否简单说明该函数的逆运算逻辑？

问题更新 #

我自己写了如下代码，但没有得到预期结果，输出值为0x7019BF10而非预期的0x7059BF10：

unsafe public uint Enc(ref uint[] Array)
{
    uint[] TempArray; 
    TempArray = new uint[4];
    uint current;
    //uint Temp_1;                          未使用
    uint Temp_2;
    uint term_0;
    uint term_1;
    uint term_2;
    uint term_3;
    uint shifted_bits;
    uint byteMask;
    uint encryptedByteMask;

    TempArray[1] = Array[0];
    TempArray[2] = Array[1];
    TempArray[3] = Array[2];
    term_3 = Array[3];
    Temp_2 = Array[2];
    term_2 = Temp_2 ^ Temp_2 >> 0x13;
    term_1 = term_3 ^ term_2;
    // Array[0]     0xCA94905E
    // Array[1]     0xBD4CE3B2
    // Array[2]     0x7C0BEDF9
    // Array[3]     0xC1177C57
    // term_1       0xBD1C9E2F  
    // term_2       0x7C0BE278
    current = term_1;
    for (int byteIndex = sizeof(uint) - 1 - 1; byteIndex >= 0; byteIndex--)
    {
        byteMask = (uint)(0xFF << (byteIndex * 8) + 8);         // 添加强制类型转换，避免int隐式转uint报错
        encryptedByteMask = current & byteMask;
        current = current ^ (encryptedByteMask >> 8);
     }
    // current = 0xBD1C9E2F BD^1C = A1
    // current = 0xBDA19E2F A1^9E = 3F
    // current = 0xBDA13F2F 3F^2F = 10
    // current = 0xBDA13F10
    term_0 = current;
    uint eleven_bit_mask = (1 << 12) - 1;
    uint current_0 = term_0;                                    // 定义current_0避免与上层作用域的current重名
    for (int msbit = 11; msbit < sizeof(uint) * 8; msbit += 11)
    {
        shifted_bits = (current_0 & eleven_bit_mask) << 11;
        current_0 = current_0 ^ shifted_bits;
        eleven_bit_mask <<= 11;
    }
    //current_0 = 0x7019BF10 但预期值为0x7059BF10
    TempArray[0] = current_0;
    Array[0] = TempArray[0];
    Array[1] = TempArray[1];
    Array[2] = TempArray[2];
    Array[3] = TempArray[3];
    return TempArray[0];
}

后续我将代码最后部分替换为求解Z = X ^ (X << Y)逆运算的通用方案后运行正常。

内容的提问来源于stack exchange，提问作者gabiz_ro