按位右移

Question

我正在尝试将这个 C 函数转换为 Python；

typedef unsigned long var;
    /* Bit rotate rightwards */
    var ror(var v,unsigned int bits) {
        return (v>>bits)|(v<<(8*sizeof(var)-bits));
    }

我尝试过谷歌搜索一些解决方案，但我似乎无法让其中任何一个给出与此处相同的结果。

这是我从另一个程序中找到的一个解决方案；

def mask1(n):
   """Return a bitmask of length n (suitable for masking against an
      int to coerce the size to a given length)
   """
   if n >= 0:
       return 2**n - 1
   else:
       return 0

def ror(n, rotations=1, width=8):
    """Return a given number of bitwise right rotations of an integer n,
       for a given bit field width.
    """
    rotations %= width
    if rotations < 1:
        return n
    n &= mask1(width)
    return (n >> rotations) | ((n << (8 * width - rotations)))

我正在尝试改变

key = 0xf0f0f0f0f123456

。 C 代码在调用时给出

000000000f0f0f12

；

ror(key, 8 << 1)

和 Python 给出；

0x0f0f0f0f0f123456

（原始输入！）

Answer 1

我在Python中找到的最短方法： （请注意，这仅适用于整数作为输入）

def ror(n,rotations,width):
    return (2**width-1)&(n>>rotations|n<<(width-rotations))

Answer 2

您的 C 输出与您提供的函数不匹配。这可能是因为您没有正确打印它。这个程序：

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

uint64_t ror(uint64_t v, unsigned int bits) 
{
    return (v>>bits) | (v<<(8*sizeof(uint64_t)-bits));
}

int main(void)
{
    printf("%llx\n", ror(0x0123456789abcdef, 4));
    printf("%llx\n", ror(0x0123456789abcdef, 8));
    printf("%llx\n", ror(0x0123456789abcdef, 12));
    printf("%llx\n", ror(0x0123456789abcdef, 16));
    return 0;
}

产生以下输出：

f0123456789abcde
ef0123456789abcd
def0123456789abc
cdef0123456789ab

要在 Python 中生成 ror 函数，我建议您参考这篇优秀的文章：http://www.falatic.com/index.php/108/python-and-bitwise-rotation

此 Python 2 代码产生与上面的 C 程序相同的输出：

ror = lambda val, r_bits, max_bits: \
    ((val & (2**max_bits-1)) >> r_bits%max_bits) | \
    (val << (max_bits-(r_bits%max_bits)) & (2**max_bits-1))

print "%x" % ror(0x0123456789abcdef, 4, 64)
print "%x" % ror(0x0123456789abcdef, 8, 64)
print "%x" % ror(0x0123456789abcdef, 12, 64)
print "%x" % ror(0x0123456789abcdef, 16, 64)

Answer 3

您的问题有不同的问题。

C部分：

您使用的 key 值是 64 位值 (

0x0f0f0f0f0f123456

)，但输出显示编译器 unsigned long 仅 32 位宽。所以 C 代码所做的就是将 32 位值

0x0f123456

旋转 16 次，得到

0x34560f12

如果您使用了

unsigned long long

（假设您的架构上它是64位，就像我的一样），您将得到

0x34560f0f0f0f0f12

（64位的旋转16次）

Python部分：

mask1和ror对width的定义不一致。

mask1

采用位宽度，其中 ror 采用字节宽度，1 个字节 = 8 位。

ror

函数应该是：

def ror(n, rotations=1, width=8):
    """Return a given number of bitwise right rotations of an integer n,
       for a given bit field width.
    """
    rotations %= width * 8  #  width bytes give 8*bytes bits
    if rotations < 1:
        return n
    mask = mask1(8 * width)  # store the mask
    n &= mask
    return (n >> rotations) | ((n << (8 * width - rotations)) & mask)  # apply the mask to result

这样使用

key = 0x0f0f0f0f0f123456

，你会得到：

>>> hex(ror(key, 16))
'0x34560f0f0f0f0f12L'
>>> hex(ror(key, 16, 4))
'0x34560f12L'

与C输出完全相同

Answer 4

我知道它已经快6岁了

我总是发现使用字符串切片比按位运算更容易。

def rotate_left(x, n):
    return int(f"{x:032b}"[n:] + f"{x:032b}"[:n], 2)

def rotate_right(x, n):
    return int(f"{x:032b}"[-n:] + f"{x:032b}"[:-n], 2)

Answer 5

def rotation_value(value, rotations, width=32):
    """ Return a given number of bitwise left or right rotations of an integer 
    value,
    for a given bit field width.
    if rotations == -rotations:
        left
    else:
        right
    """
    if int(rotations) != abs(int(rotations)):
        rotations = width + int(rotations)
    return (int(value)<<(width-(rotations%width)) | (int(value)>>(rotations%width))) & ((1<<width)-1)