Manipulación de bits de un ByteArray

Me gustaría saber cómo manipular bits de un ByteArray. Lo que necesito es cambiar los bits de acuerdo con una 'tabla' que tengo.

Mesa:

Bit 0 -> Bit 26
Bit 1 -> Bit 31
Bit 2 -> Bit 17
...
Bit 31 -> Bit 5

Convierto el ByteArray a BitArray usando este método

public static BitArray ByteArraytoBitArray(byte[] bytes)
{
    BitArray bits = new BitArray(bytes);
    return bits;
}

Pero estoy atascado allí, no sé cómo cambiar los bits de acuerdo con la tabla y luego volver a ByteArray.

EDIT:

Fragmento de código:

public static byte[] StringToByteArray(String hex)
{
    int NumberChars = hex.Length;
    byte[] bytes = new byte[NumberChars / 2];
    for (int i = 0; i < NumberChars; i += 2)
        bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
    return bytes;
}
private void button3_Click(object sender, EventArgs e)
{
    string featherearring = "00804804A02A1CA20100000000000000D2F8B6FABBB700000000000000000000";
    var strarray = StringToByteArray(featherearring);

    byte[] strarray_comp = Enc.Encrypt(strarray);

    string conv = BitConverter.ToString(strarray_comp);
    MessageBox.Show(conv.Replace("-", ""));
}



public static byte[] BitArrayToByteArray(BitArray bits)
{
    byte[] bytes = new byte[bits.Length / 8];
    bits.CopyTo(bytes, 0);
    return bytes;
}
public static byte[] Encrypt(byte[] input)
{
    BitArray source = new BitArray(input);
    BitArray target = new BitArray(source.Length);

    target[26] = source[0];
    target[31] = source[1];
    target[17] = source[2];
    target[10] = source[3];
    target[30] = source[4];
    target[16] = source[5];
    target[24] = source[6];
    target[2] = source[7];
    target[29] = source[8];
    target[8] = source[9];
    target[20] = source[10];
    target[15] = source[11];
    target[28] = source[12];
    target[11] = source[13];
    target[13] = source[14];
    target[4] = source[15];
    target[19] = source[16];
    target[23] = source[17];
    target[0] = source[18];
    target[12] = source[19];
    target[14] = source[20];
    target[27] = source[21];
    target[6] = source[22];
    target[18] = source[23];
    target[21] = source[24];
    target[3] = source[25];
    target[9] = source[26];
    target[7] = source[27];
    target[22] = source[28];
    target[1] = source[29];
    target[25] = source[30];
    target[5] = source[31];

    return BitArrayToByteArray(target);
}

mi matriz de bytes de entrada es "00804804A02A1CA20100000000000000D2F8B6FABBB700000000000000000000" y mi salida con código de zimdanen es "5012000000000000000000000000000000000000000000000000000000000000" y debe ser "501200002FD901000000000400000000BFE8C4DB140D11F40000000000000000" Como se puede ver, se pone la primera 2 bytes derecha, y los es el descanso son todos nulos.

preguntado el 03 de mayo de 12 a las 18:05

¿Tiene que ser rápido o simplemente correcto? -

Eche un vistazo a mi respuesta a [c # - desplazamiento a la izquierda de una matriz de bytes completa] [1]. [1]: stackoverflow.com/questions/8440938/… -

No me importaría si el método no fuera el más rápido, realmente me importa que haga la manipulación correctamente. -

2 Respuestas

¿Es necesario que esté en su lugar? Puede crear un nuevo BitArray y simplemente copiar los bits:

BitArray source = new BitArray(bytes);

// Create target array.
BitArray target = new BitArray(source.Length);

// Map bits.
// ...
target[26] = source[0];
// ...

O, dependiendo de cómo desee mantener su "tabla" de mapeo, puede hacerlo así:

// Setup mapping - <source, target>.
Dictionary<int, int> mapping = new Dictionary<int, int>();
// ...
mapping.Add(0, 26);
// ...

BitArray source = new BitArray(bytes);

// Create target array.
BitArray target = new BitArray(source.Length);

// Map bits.
foreach (int sourceIndex in mapping.Keys)
{
    int targetIndex = mapping[sourceIndex];
    target[targetIndex] = source[sourceIndex];
}

contestado el 03 de mayo de 12 a las 18:05

No tiene que estar en su lugar, solo necesita cambiar los bits en consecuencia y luego volver a ByteArray EDITAR: Veré su código y veré si lo hago funcionar correctamente :) - Alan Álvarez

mi matriz de bytes de entrada es "00804804A02A1CA20100000000000000D2F8B6FABBB700000000000000000000" y mi salida con su código es "5012000000000000000000000000000000000000000000000000000000000000" y debe ser "501200002FD901000000000400000000BFE8C4DB140D11F40000000000000000" Como se puede ver, se pone los 2 primeros bytes derecha, pero luego es todo anulado. - Alan Álvarez

Esta manipulación de bits es para codificar y decodificar un archivo, ¿debo cargar el archivo también? - Alan Álvarez

As Jim dicho, su mapeo solo funciona con los primeros 32 bits. Sus datos son mucho más largos que eso. Necesitas arreglar tu mapeo. - Zimdanen

¡si gracias! Voy a leer los datos en una matriz de 4 bytes a la vez. - Alan Álvarez

Su primer problema es que tiene una matriz de 32 bytes que está convirtiendo en un BitArray. Encontrará que el valor de la source.Count la propiedad es 256. target.Count, por otro lado, solo tiene 32 años. Así que tu Encrypt El método solo cambia los primeros 32 bits de la matriz de bits, lo que corresponde a cuatro bytes, ocho de sus caracteres hexadecimales. El resto de su matriz será nulo.

Puede verificar esto cambiando su BitArrayToByteArray método para llenar el destino con 0xFF antes de hacer la copia:

public static byte[] BitArrayToByteArray(BitArray bits)
{
    byte[] bytes = new byte[bits.Length / 8];
    // Fill the array with 0xFF to illustrate.
    for (int i = 0; i < bytes.Length; ++i)
    {
        bytes[i] = 0xFF;
    }
    bits.CopyTo(bytes, 0);
    return bytes;
}

Creo que encontrarás que el resultado es "50120000FFFFFF..."

Es difícil decir exactamente lo que estás tratando de hacer. Si desea codificar los bytes en su cadena, no hay necesidad de usar un BitArray. Si realmente desea codificar los bits, debe codificar TODOS los bits. Sin más información sobre lo que está tratando de hacer, no tengo una sugerencia. Excepto que tal vez debería usar uno de los muchos algoritmos de encriptación existentes en lugar de intentar crear el suyo propio.

contestado el 04 de mayo de 12 a las 13:05

¡Oh, genial! ¡gracias! Realmente no estoy tratando de escribir mi propio algoritmo aquí, solo descifrando y encriptando un archivo de un juego. :) - Alan Álvarez

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.