Tourner À Droite Au Niveau Du Bit

Je suis en train de convertir cette fonction de C en Python;

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

J'ai essayé de Googler pour certaines solutions, mais je ne peux pas sembler obtenir de leur donner les mêmes résultats que celui qui est ici.

C'est une solution que j'ai trouvé à partir d'un autre programme;

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

Je suis en train de btishift key = 0xf0f0f0f0f123456. Le code C donne 000000000f0f0f12 lorsqu'elle est appelée avec; ror(key, 8 << 1) et Python donne; 0x0f0f0f0f0f123456 (de l'entrée d'origine!)

Pourquoi êtes-vous en passant en 8 << 1pour les rotations, alors? De plus width, si vous vous retrouvez avec 0 rotations (16 % 8 est 0).
C'est dans une boucle jusqu'à 3. Donc, il va rotations seront 8 << 0, 8<<1, 8<<2.
Tous ceux qui sont plus grands que width et multiples de width, donc rotations %= width sera toujours 0.
Je comprends que. Si je change width j'obtiens des résultats qui ne sont pas encore comparable à celle de la C de sortie.
La sortie C ressemble à une rotation de 16 bits, avec un masque de 32 bits. Je n'ai aucune idée de pourquoi vous utilisez rotations %= width à tous ici.

OriginalL'auteur Jake Evans | 2014-11-27

  1. 5

    Votre C de sortie ne correspond pas à la fonction que vous avez fournis. C'est probablement parce que vous n'êtes pas à l'imprimer correctement. Ce programme:

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

    produit la sortie suivante:

    f0123456789abcde 
ef0123456789abcd 
def0123456789abc 
cdef0123456789ab

    Pour produire une ror fonction en Python je vous renvoie à cet excellent article: http://www.falatic.com/index.php/108/python-and-bitwise-rotation

    Ce Python 2 code de produit le même résultat que le programme C ci-dessus:

    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)

    OriginalL'auteur David Heffernan

  2. 3

    Il y a différents problèmes dans votre question.

    Partie C :

    Vous utilisez une valeur de clé de 64 bits (0x0f0f0f0f0f123456), mais le résultat montre que pour vous compilateur unsigned long n'est que de 32 bits de large. Donc, ce que le code C n'est tournante les 32 bits de la valeur 0x0f123456 16 fois donner 0x34560f12

    Si vous aviez utilisé unsigned long long (en supposant qu'il est de 64 bits sur architecture c'est sur le mien), vous auriez eu 0x34560f0f0f0f0f12 de rotation (16 fois 64 bits)

    Python partie :

    La définition de la largeur entre mask1 et ror n'est pas cohérente. mask1 prend une largeur en bits, où ror prend une largeur en octets, un octet = 8 bits.

    La ror fonction doit être :

    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

    De cette façon avec key = 0x0f0f0f0f0f123456, vous obtenez : 

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

    exactement la même que la sortie C

    OriginalL'auteur Serge Ballesta