php - texto - programa para conversión de binario a decimal y viceversa

Convierta una cadena en binaria y luego otra vez en PHP

Question

¿Hay alguna manera de convertir una cadena a binaria y viceversa en la biblioteca PHP estándar?

Para aclarar lo que estoy tratando de hacer es almacenar una contraseña en una base de datos. Voy a convertirlo primero usando una función hash y eventualmente almacenarlo como binario.

He encontrado que la mejor manera es usar esta función. Parece que hash y salida en binario al mismo tiempo.

http://php.net/manual/en/function.hash-hmac.php

Answer 1

¡Si seguro!

Ahí...

$bin = decbin(ord($char));

... y de regreso.

$char = chr(bindec($bin));

Answer 2

Es curioso cómo Stefan Gehrig su respuesta es la correcta. No necesita convertir una cadena en una cadena "011010101" para almacenarla en el campo BINARIO en una base de datos. De todos modos, ya que esta es la primera respuesta que aparece cuando buscas en Google "cadena de conversión php a cadena binaria". Aquí está mi contribución a este problema.

La respuesta más votado por Francois Deschenes va mal para las cadenas largas (ya sea cadenas de bits o bitstrings) que se debe a

base_convert () puede perder precisión en números grandes debido a propiedades relacionadas con el tipo interno "doble" o "flotante" utilizado. Consulte la sección Números de puntos flotantes en el manual para obtener información y limitaciones más específicas.

De: https://secure.php.net/manual/en/function.base-convert.php

Para evitar esta limitación, puede cortar la cadena de entrada en fragmentos. Las siguientes funciones implementan esta técnica.

<?php
function bytesToBits(string $bytestring) {
if ($bytestring === '''') return '''';
$bitstring = '''';
foreach (str_split($bytestring, 4) as $chunk) {
$bitstring .= str_pad(base_convert(unpack(''H*'', $chunk)[1], 16, 2), strlen($chunk) * 8, ''0'', STR_PAD_LEFT);
}
return $bitstring;
}
function bitsToBytes(string $bitstring) {
if ($bitstring === '''') return '''';
// We want all bits to be right-aligned
$bitstring_len = strlen($bitstring);
if ($bitstring_len % 8 > 0) {
$bitstring = str_pad($bitstring, intdiv($bitstring_len + 8, 8) * 8, ''0'', STR_PAD_LEFT);
}
$bytestring = '''';
foreach (str_split($bitstring, 32) as $chunk) {
$bytestring .= pack(''H*'', str_pad(base_convert($chunk, 2, 16), strlen($chunk) / 4, ''0'', STR_PAD_LEFT));
}
return $bytestring;
}
for ($i = 0; $i < 10000; $i++) {
$bytestring_in = substr(hash(''sha512'', uniqid('''', true)), 0, rand(0, 128));
$bits = bytesToBits($bytestring_in);
$bytestring_out = bitsToBytes($bits);
if ($bytestring_in !== $bytestring_out) {
printf("IN : %s/n", $bytestring_in);
printf("BITS: %s/n", $bits);
printf("OUT : %s/n", $bytestring_out);
var_dump($bytestring_in, $bytestring_out); // printf() doesn''t show some characters ..
die(''Error in functions [1].'');
}
}
for ($i = 0; $i < 10000; $i++) {
$len = rand(0, 128);
$bitstring_in = '''';
for ($j = 0; $j <= $len; $j++) {
$bitstring_in .= (string) rand(0,1);
}
$bytes = bitsToBytes($bitstring_in);
$bitstring_out = bytesToBits($bytes);
// since converting to byte we always have a multitude of 4, so we need to correct the bitstring_in to compare ..
$bitstring_in_old = $bitstring_in;
$bitstring_in_len = strlen($bitstring_in);
if ($bitstring_in_len % 8 > 0) {
$bitstring_in = str_pad($bitstring_in, intdiv($bitstring_in_len + 8, 8) * 8, ''0'', STR_PAD_LEFT);
}
if ($bitstring_in !== $bitstring_out) {
printf("IN1 : %s/n", $bitstring_in_old);
printf("IN2 : %s/n", $bitstring_in);
printf("BYTES: %s/n", $bytes);
printf("OUT : %s/n", $bitstring_out);
var_dump($bytes); // printf() doesn''t show some characters ..
die(''Error in functions [2].'');
}
}
echo ''All ok!'' . PHP_EOL;

Tenga en cuenta que si inserta una cadena de bits que no es una multitud de 8 (ejemplo: "101") no podrá recuperar la cadena de bits original cuando la convierta a bytes. Desde la conversión de la longitud de bytes, obtendrá "00000101" que es numéricamente el mismo (entero de 8 bits sin signo) pero tiene una longitud de cadena diferente. Por lo tanto, si la longitud de la cadena de bits es importante para usted, debe guardar la longitud en una variable separada y cortar la primera parte de la cadena después de la conversión.

$bits_in = "101";
$bits_in_len = strlen($bits_in); // <-- keep track if input length
$bits_out = bytesToBits(bitsToBytes("101"));
var_dump($bits_in, $bits_out, substr($bits_out, - $bits_in_len)); // recover original length with substr

Answer 3

Estaba buscando una conversión de bits de cadena y llegué aquí, si el siguiente caso es para ti //, así que ... si quieres usar los bits de una cadena en diferentes bits, tal vez este ejemplo te ayude

$string="1001"; //this would be 2^0*1+....0...+2^3*1=1+8=9
$bit4=$string[0];//1
$bit3=$string[1];
$bit2=$string[2];
$bit1=$string[3];//1

Answer 4

La forma más fácil que encontré fue convertir a HEX en lugar de una cadena. Si funciona para ti:

$hex = bin2hex($bin); // It will convert a binary data to its hex representation
$bin = pack("H*" , $hex); // It will convert a hex to binary

O

$bin = hex2bin($hex); // Available only on PHP 5.4

Answer 5

Las cadenas en PHP siempre son BLOB. Entonces puede usar una cadena para mantener el valor de su base de datos BLOB. Todas estas cosas de conversión de bases y demás tienen que ver con la presentación de ese BLOB.

Si desea una representación agradable legible por humanos de su BLOB, entonces tiene sentido mostrar los bytes que contiene, y probablemente usar hexadecimal en lugar de decimal. Por lo tanto, la cadena "41 42 43" es una buena manera de presentar la matriz de bytes que en C # sería

var bytes = new byte[] { 0x41, 0x42, 0x43 };

¡pero obviamente no es una buena forma de representar esos bytes! La cadena "ABC" es una representación eficiente, porque de hecho es el mismo BLOB (solo que no es tan grande en este caso).

En la práctica, normalmente obtendrá sus BLOB de las funciones que devuelven cadena, como la función de hash u otras funciones fread como fread .

En los casos excepcionales (pero no tan raro cuando solo estoy probando cosas / prototipos) que necesita construir una cadena a partir de algunos bytes codificados, no conozco nada más eficiente que convertir una "cadena hexadecimal" en lo que es a menudo llamado "cadena binaria" en PHP:

$myBytes = "414243";
$data = pack(''H*'', $myBytes);

Si var_dump($data); te mostrará la string(3) "ABC" . Eso es porque 0x41 = 65 decimal = ''A'' (en básicamente todas las codificaciones).

Dado que mirar datos binarios interpretándolos como una cadena no es exactamente intuitivo, es posible que desee crear un contenedor básico para facilitar la depuración. Una posible tal envoltura es

class blob
{
function __construct($hexStr = '''')
{
$this->appendHex($hexStr);
}
public $value;
public function appendHex($hexStr)
{
$this->value .= pack(''H*'', $hexStr);
}
public function getByte($index)
{
return unpack(''C'', $this->value{$index})[1];
}
public function setByte($index, $value)
{
$this->value{$index} = pack(''C'', $value);
}
public function toArray()
{
return unpack(''C*'', $this->value);
}
}

Esto es algo que cociné sobre la marcha, y probablemente sea solo un punto de partida para tu propia envoltura. Pero la idea es usar una cadena para almacenamiento ya que esta es la estructura más eficiente disponible en PHP, mientras que proporciona métodos como toArray () para usar en depuradores relojes / evaluaciones cuando desee examinar los contenidos.

Por supuesto, puede usar una matriz de PHP perfectamente sencilla en su lugar y empaquetarla en una cadena cuando interactúe con algo que use cadenas para datos binarios. Dependiendo del grado en el que realmente va a modificar el blob esto puede resultar más fácil, y aunque no es eficiente en el uso del espacio, creo que obtendrá un rendimiento aceptable para muchas tareas.

Un ejemplo para ilustrar la funcionalidad:

// Construct a blob with 3 bytes: 0x41 0x42 0x43.
$b = new blob("414243");
// Append 3 more bytes: 0x44 0x45 0x46.
$b->appendHex("444546");
// Change the second byte to 0x41 (so we now have 0x41 0x41 0x43 0x44 0x45 0x46).
$b->setByte(1, 0x41); // or, equivalently, setByte(1, 65)
// Dump the first byte.
var_dump($b->getByte(0));
// Verify the result. The string "AACDEF", because it''s only ASCII characters, will have the same binary representation in basically any encoding.
$ok = $b->value == "AACDEF";

Answer 6

Una cadena es solo una secuencia de bytes, por lo tanto, en realidad se trata de datos binarios en PHP. ¿Qué estás tratando de hacer exactamente?

EDITAR

Si desea almacenar datos binarios en su base de datos, el problema más frecuente es la definición de columna en su base de datos. PHP no diferencia entre datos binarios y cadenas, pero las bases de datos sí lo hacen. En MySQL, por ejemplo, debe almacenar datos binarios en BINARY , VARBINARY o BLOB .

Otra opción sería base64_encode su cadena PHP y almacenarla en alguna VARCHAR o TEXT en la base de datos. Pero tenga en cuenta que la longitud de la cuerda aumentará cuando se use base64_encode .

Answer 7

Definitivamente recomendaría utilizar las bibliotecas de contraseñas estándar incorporadas que vienen con PHP . Aquí hay un buen example de cómo usarlas.

Para los que vienen aquí a descubrir cómo pasar de Binary Strings a Decimales y volver, hay algunos buenos ejemplos a continuación.

Para convertir "cadenas" binarias en decimales / caracteres, puede hacer algo como esto ...

echo bindec("00000001") . "/n";
echo bindec("00000010") . "/n";
echo bindec("00000100") . "/n";
echo bindec("00001000") . "/n";
echo bindec("00010000") . "/n";
echo bindec("00100000") . "/n";
echo bindec("01000000") . "/n";
echo bindec("10000000") . "/n";
echo bindec("01000001") . "/n";
# big binary string
echo bindec("111010110111011110000110001")."/n";

Los resultados anteriores:

1
2
4
8
16
32
64
128
65
123452465

Para convertir decimales a char / cadenas, puede hacer esto:

# convert to binary strings "00000001"
echo decbin(1) . "/n";
echo decbin(2) . "/n";
echo decbin(4) . "/n";
echo decbin(8) . "/n";
echo decbin(16) . "/n";
echo decbin(32) . "/n";
echo decbin(64) . "/n";
echo decbin(128) . "/n";
# convert a ascii character
echo str_pad(decbin(65), 8, 0, STR_PAD_LEFT) ."/n";
# convert a ''char''
echo str_pad(decbin(ord(''A'')), 8, 0, STR_PAD_LEFT) ."/n";
# big number...
echo str_pad(decbin(65535), 8, 0, STR_PAD_LEFT) ."/n";
echo str_pad(decbin(123452465), 8, 0, STR_PAD_LEFT) ."/n";

Los resultados anteriores:

1
10
100
1000
10000
100000
1000000
10000000
01000001
01000001
1111111111111111
111010110111011110000110001

Answer 8

Su hash ya es binario y está listo para ser utilizado con su base de datos.

Sin embargo, debe necesitar convertirlo a un formato que la definición de la columna de la base de datos espera.

Cualquier cadena en PHP (hasta 5.3) es una cadena binaria. Eso significa que contiene solo datos binarios.

Sin embargo, debido a la compatibilidad hacia atrás con PHP 6, ya puedes convertir tu cadena explícitamente como binaria:

 $string = ''my binary string'';
$binary = b''my binary string'';

Pero eso es solo por razones de compatibilidad, en su código solo puede hacer:

 $string = $binary; // "convert" binary string into string
$binary = $string // "convert" string into binary string

Porque es lo mismo. El "convertir" es superfluo.

Answer 9

Desea usar pack y base_convert .

// Convert a string into binary
// Should output: 0101001101110100011000010110001101101011
$value = unpack(''H*'', "Stack");
echo base_convert($value[1], 16, 2);
// Convert binary into a string
// Should output: Stack
echo pack(''H*'', base_convert(''0101001101110100011000010110001101101011'', 2, 16));