¿Por qué no es la seguridad perdida por el uso de 32 bytes de claves públicas en Schnorr firmas en lugar de 33?

Actualmente existe un debate en la lista de correo acerca de truncar la 33ª edición de byte de claves públicas cuando se utiliza en bip-schnorr.

Las claves públicas son (x, y) y las coordenadas comprimido claves públicas de simplemente reemplazar el y coordinar con un solo byte que indica su rareza. La completa y coordinar entonces puede ser derivada a partir de la dada x de coordenadas, y por lo que la clave pública puede ser expresado en sólo 33 bytes en lugar de 64.

Por la eliminación de la "rareza" de bytes, claves públicas sólo será expresada por la x de coordenadas, es decir, hay dos posibles puntos sobre la curva que podría ser representado. Esto implica también que la misma coordenada x-sólo la clave pública en realidad podría ser derivada a partir de dos diferentes claves privadas.

Mi pregunta es, ¿por qué esto no afectará a la seguridad de las hipótesis de la Schnorr firma? Es sólo un efecto sutil, como la sustitución de 256 bits de seguridad con 255 bits de seguridad?

+451
Bill Bird 26 may. 2019 11:05:52
26 respuestas

Así lo hizo el multisig dirección a través de bitcoind? si usted tiene todas las claves privadas relacionadas con la que multisigned dirección añadido y en su cartera debe ser incluido automáticamente en el equilibrio y gastado.

Cita de Gavin Anderson (¿Cómo puede uno hacer multisignature las transacciones con el cliente bitcoin?) Primera respuesta allí

el gasto de multisignature transacciones-- si todas las claves privadas necesarias para pasar un multisignature transacción de la cartera, entonces esas monedas se añaden a la cartera total del bitcoin, el equilibrio y la transacción será invertido si la moneda normal-código de selección decide utilizarlos para un gasto de transacción.

si necesita instrucciones específicas para una cartera o un medio-agente sitio web, a continuación, sería útil si usted menciona exactamente qué es.

+977
bruddha 03 февр. '09 в 4:24

La Prueba de Trabajo de los algoritmos es probabilística solución para el General Bizantino del problema en el caso de que traidor generales representan estrictamente menor que el 50% de los generales.

Para simplificar, la principal cosa que una solución a este problema, que tiene que garantizar es que todos honestos generales (honesto mineros) de acuerdo en lo mismo.

Supongamos que hay 10 mineros en el blockchain de Bitcoin y una nueva transacción que viene. Esta transacción (señalar tr1) es difundido entre todos los mineros. 10 de los mineros de la traidora y difundir otra transacción (señalar tr2), donde se cambió el destinatario en tr1. Cada minero se empieza a resolver un rompecabezas sólo después de que él recibió su primera transacción de mensaje. Algunos recibirán tr1 primero, los demás recibirán tr2 primera.

El rompecabezas es bastante difícil que, en promedio, una solución cada 10 minutos. Después de 10 minutos, el minero M resuelve la prueba de trabajo de problema. Él transmite su solución a las 9 otros mineros e incluye ahí la transacción recibió primero. Al recibir esta solución, cada minero ajusta su transacción a la nueva recibido. Entonces todo el trabajo de la siguiente puzzle. Después de 1 hora, la cadena tiene 6 bloques (6 puzles resueltos). Cada general se puede evaluar la cantidad de CPU necesario para conseguir resolver 6 puzzles en 10 minutos. Cada general sabe, entonces, si la mayoría de la general ha contribuido a la construcción de esta cadena. Si la respuesta es sí, entonces se pusieron de acuerdo en la transacción dentro del bloque inicial de esta cadena.

Ahora un punto interesante: ¿y si la transacción en el principio de minado bloque es tr2? La solución que se describe aquí no impide ponerse de acuerdo sobre una transacción falsa. En el contexto de la Bizantina Generales del problema, es suficiente para que los generales a un acuerdo sobre un falso plan siempre y cuando estén de acuerdo.

+904
Storedvalue 17 feb. 2017 9:58:36

¿Cuál es el número máximo de caracteres permitidos en un Multibit contraseña, y que están permitidos los caracteres?

Desde que tengo uso de Keepass como un administrador de contraseñas, mi práctica habitual es generar contraseñas con el máximo permitido de complejidad.

+888
David Aleu 13 ago. 2015 16:46:54

Estoy tratando de obtener la respuesta para el siguiente ejemplo:

Asumir que tengo algo de bitcoin, y quiere comprar un producto de un comerciante. ¿Por qué el comerciante vender ese producto a mí para bitcoin, cuando él compró el proveedor de dólares?

+830
nifadaty 2 ago. 2012 13:22:26

Estoy tratando de configurar el bitcoin core build , ya que el uso de hacer , he recibido el siguiente problema .

~/Desktop/bitcoin$ make
Haciendo que todos en el src
make[1]: Entrar en el directorio '/home/fu/Desktop/bitcoin/src'
hacer todo recursiva
make[2]: Entrar en el directorio '/home/fu/Desktop/bitcoin/src'
Hacer de todo .
hacer que[3]: Entrar en el directorio '/home/fu/Desktop/bitcoin/src'
 CXX addrman.o
En el archivo incluido desde el chainparams.h:9:0,
 de protocolo.h:13,
 de addrman.h:9,
 de addrman.cpp:5:
bignum.h:56:24: error: invalid uso de tipo incompleta 'BIGNUM {aka struct bignum_st}'
 clase CBigNum : público BIGNUM
^~~~~~
En el archivo incluido desde /usr/include/openssl/crypto.h:31:0,
 de asignadores.h:15,
 de serializar.h:9,
 de netbase.h:13,
 de addrman.h:8,
 de addrman.cpp:5:
/usr/include/openssl/ossl_typ.h:80:16: nota: en adelante la declaración de 'BIGNUM {aka struct bignum_st}'
 typedef struct bignum_st BIGNUM;
^~~~~~~~~
En el archivo incluido desde el chainparams.h:9:0,
 de protocolo.h:13,
 de addrman.h:9,
 de addrman.cpp:5:
bignum.h: En el constructor 'CBigNum::CBigNum()':
bignum.h:61:9: error: 'BN_init' no se declaró en este ámbito
BN_init(este);
^~~~~~~
bignum.h:61:9: nota: se sugiere la alternativa: 'BN_print'
BN_init(este);
^~~~~~~
BN_print
bignum.h: En el constructor de copia 'CBigNum::CBigNum(const CBigNum&)':
bignum.h:66:9: error: 'BN_init' no se declaró en este ámbito
BN_init(este);
^~~~~~~
bignum.h:66:9: nota: se sugiere la alternativa: 'BN_print'
BN_init(este);
^~~~~~~
BN_print
bignum.h:67:30: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'BIGNUM* BN_copy(BIGNUM*, const BIGNUM*)'
 si (!BN_copy(este, &b))
^
bignum.h:69:31: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'void BN_clear_free(BIGNUM*)'
BN_clear_free(este);
^
bignum.h: En función de miembro de 'CBigNum& CBigNum::operator=(const CBigNum&)':
bignum.h:76:30: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'BIGNUM* BN_copy(BIGNUM*, const BIGNUM*)'
 si (!BN_copy(este, &b))
^
bignum.h: En el destructor 'CBigNum::~CBigNum()':
bignum.h:83:27: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'void BN_clear_free(BIGNUM*)'
BN_clear_free(este);
^
bignum.h: En el constructor 'CBigNum::CBigNum(signed char)':
bignum.h:87:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(signed char n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
bignum.h:87:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(signed char n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(short int)':
bignum.h:88:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(corto n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
bignum.h:88:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(corto n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(int)':
bignum.h:89:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(int n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
bignum.h:89:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(int n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(long int)':
bignum.h:90:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(long n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
bignum.h:90:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(long n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(long long int)':
bignum.h:91:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(long long n) { BN_init(este); setint64(n); }
^~~~~~~
bignum.h:91:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(long long n) { BN_init(este); setint64(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(unsigned char)':
bignum.h:92:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(unsigned char n) { BN_init(este); setulong(n); }
^~~~~~~
bignum.h:92:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(unsigned char n) { BN_init(este); setulong(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(short unsigned int)':
bignum.h:93:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(unsigned short n) { BN_init(este); setulong(n); }
^~~~~~~
bignum.h:93:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(unsigned short n) { BN_init(este); setulong(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(unsigned int)':
bignum.h:94:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(unsigned int n) { BN_init(este); setulong(n); }
^~~~~~~
bignum.h:94:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(unsigned int n) { BN_init(este); setulong(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(long unsigned int)':
bignum.h:95:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(unsigned long n) { BN_init(este); setulong(n); }
^~~~~~~
bignum.h:95:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(unsigned long n) { BN_init(este); setulong(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(long long unsigned int)':
bignum.h:96:37: error: 'BN_init' no se declaró en este ámbito
 CBigNum(unsigned long long n) { BN_init(este); setuint64(n); }
^~~~~~~
bignum.h:96:37: nota: se sugiere la alternativa: 'BN_print'
 CBigNum(unsigned long long n) { BN_init(este); setuint64(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(uint256)':
bignum.h:97:37: error: 'BN_init' no se declaró en este ámbito
 explícito CBigNum(uint256 n) { BN_init(este); setuint256(n); }
^~~~~~~
bignum.h:97:37: nota: se sugiere la alternativa: 'BN_print'
 explícito CBigNum(uint256 n) { BN_init(este); setuint256(n); }
^~~~~~~
BN_print
bignum.h: En el constructor 'CBigNum::CBigNum(const std::vector&)':
bignum.h:101:9: error: 'BN_init' no se declaró en este ámbito
BN_init(este);
^~~~~~~
bignum.h:101:9: nota: se sugiere la alternativa: 'BN_print'
BN_init(este);
^~~~~~~
BN_print
bignum.h: En función de miembro de 'void CBigNum::setulong(long unsigned int)':
bignum.h:107:33: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_set_word(BIGNUM*, long unsigned int)'
 si (!BN_set_word(este, n))
^
bignum.h: En función de miembro de 'long unsigned int CBigNum::getulong() const':
bignum.h:113:32: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'long unsigned int BN_get_word(const BIGNUM*)'
 volver BN_get_word(este);
^
bignum.h: En función de miembro de 'unsigned int CBigNum::getuint() const':
bignum.h:118:32: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'long unsigned int BN_get_word(const BIGNUM*)'
 volver BN_get_word(este);
^
bignum.h: En función de miembro de 'int CBigNum::getint() const':
bignum.h:123:43: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'long unsigned int BN_get_word(const BIGNUM*)'
 unsigned long n = BN_get_word(este);
^
bignum.h:124:33: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_is_negative(const BIGNUM*)'
 si (!BN_is_negative(este))
^
En el archivo incluido desde el chainparams.h:9:0,
 de protocolo.h:13,
 de addrman.h:9,
 de addrman.cpp:5:
bignum.h: En función de miembro de 'void CBigNum::setint64(int64_t)':
bignum.h:172:37: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '3' a 'BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)'
 BN_mpi2bn(pch, p - pch, this);
^
bignum.h: En función de miembro de 'void CBigNum::setuint64(uint64_t)':
bignum.h:199:37: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '3' a 'BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)'
 BN_mpi2bn(pch, p - pch, this);
^
bignum.h: En función de miembro de 'void CBigNum::setuint256(uint256)':
bignum.h:227:37: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '3' a 'BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)'
 BN_mpi2bn(pch, p - pch, this);
^
bignum.h: En función de miembro de 'uint256 CBigNum::getuint256() const':
bignum.h:232:50: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_bn2mpi(const BIGNUM*, unsigned char*)'
 unsigned int nSize = BN_bn2mpi(este, NULL);
^
bignum.h:236:32: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_bn2mpi(const BIGNUM*, unsigned char*)'
 BN_bn2mpi(este, &vch[0]);
^
bignum.h: En función de miembro de 'void CBigNum::setvch(const std::vector&)':
bignum.h:257:46: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '3' a 'BIGNUM* BN_mpi2bn(const unsigned char*, int, BIGNUM*)'
 BN_mpi2bn(&vch2[0], vch2.size(), this);
^
bignum.h: En función de miembro de 'std::vector CBigNum::getvch() const':
bignum.h:262:50: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_bn2mpi(const BIGNUM*, unsigned char*)'
 unsigned int nSize = BN_bn2mpi(este, NULL);
^
bignum.h:266:32: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_bn2mpi(const BIGNUM*, unsigned char*)'
 BN_bn2mpi(este, &vch[0]);
^
bignum.h: En función de miembro de 'CBigNum& CBigNum::SetCompact(unsigned int)':
bignum.h:302:36: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_set_word(BIGNUM*, long unsigned int)'
 BN_set_word(este, nWord);
^
bignum.h:306:36: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_set_word(BIGNUM*, long unsigned int)'
 BN_set_word(este, nWord);
^
bignum.h:307:46: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_lshift(BIGNUM*, const BIGNUM*, int)'
 BN_lshift(este, esta, 8*(nSize-3));
^
bignum.h:309:40: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'void BN_set_negative(BIGNUM*, int)'
 BN_set_negative(este, fNegative);
^
En el archivo incluido desde el bignum.h:17:0,
 de chainparams.h:9,
 de protocolo.h:13,
 de addrman.h:9,
 de addrman.cpp:5:
bignum.h: En función de miembro de 'unsigned int CBigNum::GetCompact() const':
bignum.h:315:30: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_num_bits(const BIGNUM*)'
 unsigned int nSize = BN_num_bytes(este);
^
En el archivo incluido desde el chainparams.h:9:0,
 de protocolo.h:13,
 de addrman.h:9,
 de addrman.cpp:5:
bignum.h:318:40: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'long unsigned int BN_get_word(const BIGNUM*)'
 nCompact = BN_get_word(este) 0)
^
bignum.h:381:54: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_div(BIGNUM*, BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)'
 si (!BN_div(&dv, y rem, &bn, &bnBase, pctx))
^
bignum.h:387:32: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_is_negative(const BIGNUM*)'
 si (BN_is_negative(este))
^
bignum.h: En función de miembro de 'bool CBigNum::operator!() const':
bignum.h:420:31: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_is_zero(const BIGNUM*)'
 volver BN_is_zero(este);
^
bignum.h: En función de miembro de 'CBigNum& CBigNum::operator+=(const CBigNum&)':
bignum.h:425:35: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_add(BIGNUM*, const BIGNUM*, const BIGNUM*)'
 si (!BN_add(este, esta, &b))
^
bignum.h: En función de miembro de 'CBigNum& CBigNum::*operador=(const CBigNum&)':
bignum.h:439:41: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_mul(BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)'
 si (!BN_mul(este, esta, &b, pctx))
^
bignum.h: En función de miembro de 'CBigNum& CBigNum::operador>=(unsigned int)':
bignum.h:469:28: error: no se puede convertir 'CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_cmp(const BIGNUM*, const BIGNUM*)'
 si (BN_cmp(&a,) > 0)
^
bignum.h:475:41: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_rshift(BIGNUM*, const BIGNUM*, int)'
 si (!BN_rshift(este, esta, shift))
^
bignum.h: En función de miembro de 'CBigNum& CBigNum::operator++()':
bignum.h:484:47: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_add(BIGNUM*, const BIGNUM*, const BIGNUM*)'
 si (!BN_add(este, esta, BN_value_one()))
^
bignum.h: En función de miembro de 'CBigNum& CBigNum::operator--()':
bignum.h:501:45: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_sub(BIGNUM*, const BIGNUM*, const BIGNUM*)'
 si (!BN_sub(&r, este, BN_value_one()))
^
bignum.h: En la función 'const CBigNum operator+(const CBigNum&, const CBigNum&)':
bignum.h:526:27: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_add(BIGNUM*, const BIGNUM*, const BIGNUM*)'
 si (!BN_add(&r, &a, &b))
^
bignum.h: En la función 'const CBigNum operador(const CBigNum&, const CBigNum&)':
bignum.h:534:27: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_sub(BIGNUM*, const BIGNUM*, const BIGNUM*)'
 si (!BN_sub(&r, &a, &b))
^
bignum.h: En la función 'const CBigNum operador(const CBigNum&)':
bignum.h:542:43: error: no se puede convertir 'CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_is_negative(const BIGNUM*)'
 BN_set_negative(&r, !BN_is_negative(&r));
^
bignum.h: En la función 'const CBigNum operator*(const CBigNum&, const CBigNum&)':
bignum.h:550:33: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_mul(BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)'
 si (!BN_mul(&r, &a, &b, pctx))
^
bignum.h: En la función 'const CBigNum operador/(const CBigNum&, const CBigNum&)':
bignum.h:559:39: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '1' a 'int BN_div(BIGNUM*, BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)'
 si (!BN_div(&r, NULL, &a, &b, pctx))
^
En el archivo incluido desde el bignum.h:17:0,
 de chainparams.h:9,
 de protocolo.h:13,
 de addrman.h:9,
 de addrman.cpp:5:
bignum.h: En la función 'const CBigNum operador%(const CBigNum&, const CBigNum&)':
bignum.h:568:10: error: no se puede convertir 'CBigNum*' a 'BIGNUM* {aka bignum_st*}' para el argumento de '2' a 'int BN_div(BIGNUM*, BIGNUM*, const BIGNUM*, const BIGNUM*, BN_CTX*)'
 si (!BN_mod(&r, &a, &b, pctx))
^
En el archivo incluido desde el chainparams.h:9:0,
 de protocolo.h:13,
 de addrman.h:9,
 de addrman.cpp:5:
bignum.h: En la función 'const CBigNum operator=(const CBigNum&, const CBigNum&)':
bignum.h:591:83: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_cmp(const BIGNUM*, const BIGNUM*)'
 mu& a, const CBigNum& b) { return (BN_cmp(&a, &b) >= 0); }
^
bignum.h: En la función 'bool operator(const CBigNum&, const CBigNum&)':
bignum.h:593:83: error: no se puede convertir 'const CBigNum*' a 'const BIGNUM* {aka const bignum_st*}' para el argumento de '1' a 'int BN_cmp(const BIGNUM*, const BIGNUM*)'
 mu& a, const CBigNum& b) { return (BN_cmp(&a, &b) > 0); }
^
En el archivo incluido desde util.h:15:0,
 de addrman.h:11,
 de addrman.cpp:5:
tinyformat.h: En función miembro estática 'static const char* tinyformat::detalles::FormatIterator::streamStateFromFormat(std::ostream&, unsigned int&, const char*, int, int)':
tinyformat.h:784:21: advertencia: esta declaración puede caer a través de [-Wimplicit-fallthrough=]
a cabo.setf(std::ios::uppercase);
~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
tinyformat.h:785:9: nota: aquí
 el caso de 'x': case 'p':
^~~~
tinyformat.h:790:21: advertencia: esta declaración puede caer a través de [-Wimplicit-fallthrough=]
a cabo.setf(std::ios::uppercase);
~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
tinyformat.h:791:9: nota: aquí
 case 'e':
^~~~
tinyformat.h:796:21: advertencia: esta declaración puede caer a través de [-Wimplicit-fallthrough=]
a cabo.setf(std::ios::uppercase);
~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
tinyformat.h:797:9: nota: aquí
 case 'f':
^~~~
tinyformat.h:801:21: advertencia: esta declaración puede caer a través de [-Wimplicit-fallthrough=]
a cabo.setf(std::ios::uppercase);
~~~~~~~~^~~~~~~~~~~~~~~~~~~~~
tinyformat.h:802:9: nota: aquí
 caso de la "g":
^~~~
Makefile:838: receta para el destino " addrman.o' error
hacer que[3]: *** [addrman.o] Error 1
hacer que[3]: Dejar el directorio '/home/fu/Desktop/bitcoin/src'
Makefile:860: receta para el objetivo de 'todo recursiva' error
make[2]: *** [all-recursive] Error 1
make[2]: Dejar el directorio '/home/fu/Desktop/bitcoin/src'
Makefile:652: receta para el objetivo de 'todos' no se pudo
make[1]: *** [todos] Error 2
make[1]: Dejar el directorio '/home/fu/Desktop/bitcoin/src'
Makefile:509: receta para el objetivo de 'todo recursiva' error
marca: *** [all-recursive] Error 1

¿Cómo puedo solucionar esto ? Gracias de antemano !

+812
user140683 24 jun. 2014 7:37:21

Usted necesita para extraer la clave privada a partir de blockchain.info y conseguir que se importan en bitcoin core. Ver aquí:

No sé cómo exportar una clave privada a partir de blockchain.info

Puede que sea necesario repetir este paso, si usted tiene varias carteras en blockchain.info. Una vez hecho esto, es como tener dos carteras, con el mismo privkey. Nada impide que se utiliza tanto.

+799
richdreamz 18 feb. 2013 4:08:08

Puede alguien explicarme por qué el Bitcoin secuencias de comandos del sistema es, a propósito, no de Turing-completo? Para que los programas maliciosos difícil desarrollar (supongo)? O porque era difícil hacer Turing-completo?

Bitcoin utiliza un sistema de scripting para las transacciones. Adelante-como, de secuencia de Comandos es simple, basado en la pila, y se procesan de izquierda a derecha. Es a propósito, no de Turing-completo, sin bucles.

Recuperado de: https://en.bitcoin.it/wiki/Script.

+782
Pulkit Aditya 21 dic. 2011 14:57:35

uso el msi afterburner, establecer su gpu ventiladores de 80% y un TDP de 70%, a continuación, jugar con el reloj del núcleo y del reloj de la memoria, tal vez +100/+450 es un buen lugar para empezar

esto le dará un mejor enfriamiento, menores costos de energía y mejor hash de las tasas de

+779
Sahith Gangineni 2 feb. 2019 1:39:45

He estado pensando en esto por un tiempo y parece que no puede entender una parte de la red.

Supongamos que yo soy un nodo que ha estado desconectado durante 5 meses y quiero recuperar los nuevos bloques. Cuando me difusión de la getblocks mensaje de los diferentes nodos de ver, todos mis compañeros de responder o hacer algunos de ellos responden y los demás lo ignoran, porque de las otras respuestas? Y si todos ellos responden de nuevo, mi nodo, a continuación, elija la que/los que se quiere obtener los datos de, o es obtener los datos de todos ellos? Si obtiene los datos de todos ellos, entonces no se que lento el sistema mucho y generar mucho más tráfico en la red?

+773
Mokubai 21 jul. 2013 5:47:01

Suponiendo que SHA-256 es no guardar más. ¿Cómo podría el blockchain de Bitcoin atacado? Ok yo podría obtener el valor de la entrada para la función de hash, pero podría fácilmente añadir mis propios bloques de la cadena? Actualmente estoy confundido ¿por qué hay tesis hash utilizado...

Cuánto tiempo se necesitaría para atacar el hash ahora, con un trabajo SHA-256. ¿Podría proporcionarme un cálculo con GFLOPS o algo?

saludos

+755
The Source 2 ago. 2019 11:00:59

Supongamos que tenemos una red con n nodos en ella. Es posible que, cuando el hash de alimentación de la red se calcula después de una prueba de trabajo, para estimar con precisión n con un algoritmo de tomar el hash calculado la potencia en cuenta?

+694
Phyu Sin Khaing 27 abr. 2012 0:41:17

Tal vez pyCoin puede ser útil para su propósito? https://github.com/richardkiss/pycoin/blob/master/COMMAND-LINE-TOOLS.md

+680
NomadNYC 5 ene. 2016 13:29:18

Creo que todavía se puede hacer que si alguien ejecuta un completo nodo (sin poda) va a hacer un bootstrap.dat.

De https://bitcoin.org/bin/block-chain/README.txt:

Como de Bitcoin Core versión 0.10.0 y más tarde, el bloque de la cadena de bootstrap torrent alojados aquí toma más tiempo para descargar e importar de lo que sería simplemente iniciar Bitcoin Core y deje que se sincroniza.

Hilo en el foro de BitcoinTalk:
https://bitcointalk.org/index.php?topic=145386.0

Bitcoin-Qt/bitcoind versión 0.7.1 y más tarde admite una especial característica de importación: Si el archivo bootstrap.dat" se encuentra en el bitcoin datos de directorio, validar e importar todos los blockchain de datos que se encuentra en ese archivo. El siguiente torrent presenta un bootstrap.archivo dat para la entidad.

De https://github.com/bitcoin-dot-org/:

Como de Bitcoin Core versión 0.10.0 y más tarde, el bloque de la cadena de bootstrap torrent anteriormente alojado aquí es más lento que una descarga directa el uso de el bitcoin protocolo P2P y cliente. Si desea que el torrent para otros razones, por favor visite:

https://bitcointalk.org/index.php?topic=145386.0

Para descargar la última versión de Bitcoin Core, por favor visite:

https://bitcoin.org/en/download

Además de la lectura, la vinculada bitcoin.hablar de la página:

Actualizado: 23 De Agosto De 2014

También la comprobación de https://bitcoin.org/bin/block-chain/:

24-Aug-2014 01:40

Creo que todavía se puede hacer esto si alguien ejecuta un completo nodo (sin poda) va a hacer un bootstrap.dat sin embargo su confianza en el proveedor debe ser implícita.

Si desea mantener sólo un número limitado de bloques, que permiten a podar={bytes} con bytes > 550 en el bitcoin.conf archivo.

+622
Rafael Salvador 4 may. 2018 21:46:15

Alguien puede explicar a un alto nivel de cómo la red se ocupa con malos actores (ya sea intencionalmente (ie - atacante) o no intencional (es decir, - mal configurado el nodo o un nodo que ejecuta código obsoleto, bifurcada, código, etc)) ?

Sin saber mucho acerca de Bitcoin del bajo nivel de componentes internos, estoy asumiendo que existen los controles de rutina como flujos de datos a través del código en la red para comprobar que el protocolo está adherido; y que nada fuera de protocolo esperado se convierte rechazado o marcado. Supongo que estos cheques son todos esencialmente marcada exclusivamente en contra de la esperada "modelo de datos" ya que, obviamente, es imposible analizar directamente lo que el código se ejecuta en mineros independientes/nodos.

Así que por favor me corrija si estoy equivocado aquí, o elaborar más a llenar en el panorama un poco más.

En segundo lugar, yo quería saber - en el caso de un conocido hostil minero/nodo (o, en menor medida, un conocido desactualizado o mal configurado la red participante) - ¿con qué recurso disponible para otros usuarios o a los mineros a 'informe' o lista negra o evitar los nodos afectados o transacciones?

Es decir - es que hay construido en la función para denunciar una violación de protocolo (que puede ser ejecutado en el atacante del sistema o por medio de otros participantes en la red de identificación, dijo el atacante) ?

Su aclaración apreciado, gracias !

+602
Katastic Voyage 26 jun. 2012 21:19:05

Así que ayer me fue enviando a algunos de bitcoin para depositar en mi whaleclub.co cuenta de como hice la vez anterior antes sin problemas, aunque esta vez está diciendo que mi bitcoins fueron enviados a una dirección diferente a los otros que la mía. Cuando miro a mi coinbase transacciones y seguir la transacción mi enviado bitcoins permanecer en esa dirección. ¿Cómo puedo recuperarlos ? Cualquier ayuda sería impresionante.

+478
Thomas Zammit 12 ago. 2019 4:25:22

Aquí está mi "bastante grande respuesta": He utilizado con éxito http://cryptolife.net/upwg/ que se indica "código Abierto JavaScript del Lado del Cliente de Papel Universal Cartera Generador".

No generar cartera de direcciones por coinname, sino por el carácter de líder dentro de la cartera de dirección. Me estas desde el bloque explorer para la moneda, busca en la parte superior de dirección.

http://www.universalwalletgenerator.net/ te permite hacerlo por el nombre de la moneda.

+458
everding 27 sept. 2016 7:37:33

Estoy echando un vistazo a la historia de los precios del Bitcoin/USD, y hay un punto significativo en torno a finales de 2013 (USD 1137), seguido por un muy volátil año en 2014, que terminó con Bitcoin alrededor de USD 330.

¿Hay alguien que le sigue Bitcoin desde 2013 que se puede comentar sobre este volatilidad de los precios de la acción? En particular, me interesa saber: ¿qué causó la espectacular hasta USD ~1140 a finales de 2013, y ¿por qué el precio de descender a los niveles actuales?

Muchas gracias!

+411
user47322 17 may. 2016 22:05:26

Por qué iba alguien a utilizar este método en lugar de decir Paypal y como consumidor estoy protegido de alguna manera?

Bitcoin ofrece protección en diferentes formas, puede ser utilizado para el pago de bienes y servicios, pero la naturaleza de este sistema de pago es bastante distinto a algo como Paypal.

Con Paypal, el sistema es dirigido por un centralizada de las partes (Paypal). Esto significa que Paypal puede funcionar como el árbitro de las disputas que es la manera en que ofrecen protección al consumidor. Si un vendedor le estafa, usted puede abrir una disputa, y Paypal puede simplemente decidir revocar los fondos del vendedor, y volver a usted. Como usuario, usted debe confiar en que Paypal va a actuar de manera justa en todas las cuentas, y no restringir el acceso a su dinero en cualquier forma.

Bitcoin es diferente: el sistema es descentralizado, lo que significa que no hay partido central que puede realizar cambios en el estado del sistema de forma arbitraria. Una vez que una transferencia de bitcoins ha sido confirmado, la única manera de que esos bitcoins puede nunca ser trasladado de nuevo es si el propietario de la clave privada para que la dirección de signos de una transacción de moverse.

Esto significa que si usted envía tus bitcoins a alguien a cambio de algunos bienes, y rip off de alguna manera, no hay manera que usted puede apelar a una figura de autoridad para tener tus bitcoins devuelta a usted. La única persona que puede autorizar una transacción de devolución sería la persona que envía las monedas.

Esto también significa que usted no tiene que confiar en nadie para defender su soberanía financiera. Para muchos usuarios de Paypal, esto probablemente no es un problema, ya que con el uso de Paypal para 'regular de las cosas". Pero para muchos otros, el uso de Paypal puede ser restringido por razones políticas, o porque el tipo de transacciones que hacen, no están permitidos por Paypal políticas. Para los usuarios, una garantía de la soberanía financiera es muy importante!

Como se ha mencionado por otros, si vas a comprar mercancías a través de Bitcoin, usted debe ser diligente:

  • Haga lo que pueda para asegurarse de que el vendedor es de fiar. ¿Su sitio web un aspecto de fiar? Incluye la información de contacto para una fiar de negocios? Puedes encontrar muchas revisiones independientes de su negocio en línea?
  • Considere la posibilidad de hacer su primera compra una pequeña, así que usted puede construir algo de confianza en que el negocio va a entregar como se anuncia para una compra mayor.
  • El uso de un servicio de custodia para completar la transacción. Básicamente, esto repercute en el arbitraje deber de Paypal a una tercera parte neutral en el ecosistema bitcoin.

Quizás vale la pena mencionar que mientras que bitcoin puede funcionar como un sistema de pago en línea, que no implica la plena medida de su utilidad. Dicho de otra manera, bitcoin es de utilidad no es simplemente un 'Paypal 2.0', es útil porque puede hacer cosas que ningún otro instrumento monetario puede. Bitcoin es un permiso de menos, la censura-resistente, descentralizada, sin fronteras, con sistema programable de valor. Las implicaciones de esto son que es un debate que está aún en desarrollo.

+362
bzle 3 mar. 2013 12:38:07

He creado un paper wallet mediante bitaddress.org y pasó bitcoins en ella utilizando el Coinbase móvil (Android App). Entonces me di cuenta de que el papel de la cartera cortar parte de la clave privada durante la impresión! No lo deje fuera suficiente espacio para toda la clave privada. Necesito conseguir los bitcoins de la espalda de esa cartera/dirección utilizando sólo el código QR. No puedo entender cómo utilizar el Coinbase aplicación móvil para hacer eso. Al parecer puede enviar a un código QR, pero no recibe de uno.

+352
Nii 1 dic. 2010 16:15:00

Si usted está buscando una solución que se ejecutan en linux, entonces siempre hay un wget comando:

wget -q -O - https://mtgox.com/code/ticker.php

Se puede ejecutar en un bucle en un terminal :)

Bajo el entorno de escritorio xfce podría utilizar el genmon panel de complementos y alimentar Mt. Gox los últimos datos de comercio. Hablando de lo cual, creo que voy a hacer yo. :)

+296
pendalf55 31 jul. 2011 10:35:21

No necesariamente interoperables.

En primer lugar, las bibliotecas tienen que ponerse de acuerdo sobre qué tipo de parámetros para el intercambio y ¿cómo se realiza el intercambio. No hay ninguna garantía de que los parámetros requeridos por bitcoinj y libbitcoin son los mismos.

En segundo lugar, se considera ahora una práctica estándar para crear P2SH las transacciones, independientemente de qué tipo de transacción que se está configurando, a menos que se P2PKH. En el caso de P2SH transacciones, entonces usted tiene que afirmar que el pago protocolo de canal también sería capaz de analizar/reconocer/comprender la canjear script proporcionado por un proveedor de servicio de pago de canal (suponiendo que estamos hablando de una sola dirección de pago de canal).

+291
Zasiliou 24 feb. 2018 2:44:07

No todas las crypto monedas están utilizando secp256k1 tecnología para la generación del par de claves y firmas digitales. Curve25519 tecnología (utiliza con frecuencia para apoyar ECDH los intercambios de claves) está siendo utilizado por algunos otros cryptocurrencies. Ed25519 criptografía (destinados a apoyar la EdDSA funcionalidad) y Curve25519 criptografía están estrechamente relacionados a través de las transformaciones y la tendencia es a empezar con Ed25519 claves y transformarlas Curve25519 pares de claves.

Estado usando esta referencia como una fuente de ocho ED25519_SECRET_KEYS y correspondiente ED25519_PUBLIC_KEYS para su uso como vectores de pruebas para la aplicación de Ed25519 implementaciones de paquetes.

Tengo floodyberry/ed25519-donna funcionando como se esperaba. Sin embargo, yo no podía calcular el ED25519_CURVE25519_PUBLIC_KEYS de la referencia mediante ed25519-donna utilizando su curved25519_scalarmult_basepoint() función para que coincida. Esto me empujó hacia tratando de jedisct1/libsodium. Tengo crypto_scalarmult_base() resultados de la función de libsodium coincidan con los de ed25519-donna:-)

Sin embargo, no está claro cómo jedisct1/libsodium pueden ser aplicados para generar pública Ed25519 solo las teclas de secreto Ed25519 claves que son de forma nativa en un ASCII formato hexadecimal:-( parece que jedisct1/libsodium requiere claves para siempre ser generado a partir de este nativo proceso de generación del par de claves, en contraposición a una suministrado externamente clave privada.

Utiliza el sodium_hex2bin() a cosas ASCII hexadecimal codificado con la clave privada de la referencia en el 64 unsigned char ed25519_skpk variable:

sodium_hex2bin( ed25519_skpk, 32, ED25519_SECRET_KEYS[ii], 64, NULL, NULL, NULL );

Resultados de la siguiente libsodium función fueron como se esperaba:

crypto_scalarmult_base( curve25519_pk, ed25519_skpk )

Estaba un poco frustrado cuando descubrí que crypto_sign_ed25519_sk_to_pk() fue codificado para extraer la clave pública de ed25519_skpk que nunca fue inicializado.

crypto_sign_ed25519_sk_to_pk( ed25519_pk, ed25519_skpk );

Cada vez un poco decepcionado por no localizar a un libsodium la función para calcular el ed25519_pk clave cuando ed25519_skpk se carga con un trabajo clave privada a partir de una fuente externa. Cualquier ayuda será muy apreciada.

+291
Mitrakov Artem 14 ago. 2017 14:30:33

En la actual tarifa promedio en Bitcoin de red puede establecer fácilmente 2 satoshis por byte como tx cuota si usted no está en una prisa para tener usted transacción confirmada en el primer bloque después de que lo envíe.

Gráfica info aquí: https://bitinfocharts.com/comparison/bitcoin-transactionfees.html#3m

+116
Stanley Yu 30 jun. 2019 18:21:08

Me gustaría pagar un minero de la cuota. Lugares como MtGox permitir la opción de añadir uno. Me gustaría agregar uno. A menudo voy a añadir 0.0005 BTC a la final de la cantidad, pero no de los mineros tomar a mi cargo. Puedo preguntarte cómo puedo obtener los buenos, trabajadores, mineros a tomar a mi cargo?

+94
Max Merz 5 abr. 2019 19:28:36

Estoy atascado en esta pensado para una, mientras que en el bloque de la tasa de generación. Mi preocupación es que, cuando un pagador espera 10 minutos para confirmar que su operación se incluye en un bloque, se sugiere que un nuevo bloque se genera en 10 minutos, debido a que su transacción es nuevo y el bloque incluye. Entonces, ¿cómo hace un minero hacer que en tan sólo 10 minutos? ¿No se supone que ser duro? El minero puede llegar a ser un millonario en meses.

¿El bloque de la tasa de generación implica que, una vez que un minero se inicia el cómputo de la prueba-de-trabajo(POW) ella tiene éxito en conseguir el nonce después de 10 minutos? O es el caso de los mineros de cálculo PRISIONERO de guerra a su propio ritmo(probablemente por un largo tiempo suficiente) y 1 bloque de nuevo aparece cada 10 minutos. Si el 2º escenario es cierto, ¿cómo se justifica el tiempo de espera?

Gracias.

+59
CurseStacker 30 may. 2019 2:36:54

No, la transacción no será aprobado. Hay diferencias en el formato de transacción. Las transacciones no son válidos entre 2 tenedores.

+29
amily 29 may. 2018 10:27:33

Mostrar preguntas con etiqueta