Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Temas - AlbertoBSD

#1
#if 0
//Code
#endif


Es mi duda, Se ejecuta o no se ejecuta el codigo, Lo comento por que estoy migrando parte de una funcion en programa a otro:

Linea 210 de https://github.com/JeanLucPons/BSGS/blob/master/BSGS.cpp

#if 0
     pp.y.ModSub(&Gn[i].x,&pp.x);
     pp.y.ModMulK1(&_s);
     pp.y.ModSub(&Gn[i].y);           // ry = - p2.y - s*(ret.x-p2.x);  
#endif


Hay varias partes del codigo asi, y mi pregunta es, si no se ocupan para que estan ahi? Si fueran referencia yo las hubiese comentado en lugar de poner ese if 0



Edit

Acabo de comprobarlo, No, no se ejecuta

#include<stdio.h>

int main(){
int  i = 10;
printf("%i\n",i);
#if 0
i = 200;
#endif
printf("%i\n",i);
}


C:\codigos>testif.exe
10
10


¿Por que esta ahí entonces ese segmento de código?

Saludos!
#2
Criptografía / Keyhunt
8 Abril 2021, 17:06 PM
Buenos días a todos. Quiero abrir este tema para presentar la herramienta que he estado desarrollando en los últimos meses.

Se llama keyhunt y sirve para buscar llaves privadas de criptomonedas (La mayoría de criptomonedas utilizan la misma curva elíptica y por eso se pueden atacar varios al mismo tiempo solo es cuestión de saber que datos se tiene y que se esta haciendo
)

keyhunt utiliza varios métodos para hacerlo y es bastante adaptable, podras desde tu android buscar resolver puzzles de hasta 1.6 bitcoin a una velocidadde Gigakeys/s o Terakeys/s

Link: https://github.com/albertobsd/keyhunt

Yo lo estoy utilizando para tratar de romper unos puzzles de los cuales ya abrí un hilo en este mismo subforo :Rompecabezas de Bitcoin, Medio millón USD en premios

Metodos disponibles


  • address
  • rmd160
  • xpoint
  • pub2rmd
  • bsgs

metodo address

Este método es el mas rudimentario ataque por fuerza bruta que pueda existir y consiste en buscar una privatekey que genere el address indicado.

Ejemplo del archivo de entrada:

1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
1CUNEBjYrCn2y1SdiUMohaKUi4wpP326Lb
19ZewH8Kk1PDbSNdJ97FP4EiCjTRaZMZQA
1EhqbyUMvvs7BfL8goY6qcPbD6YKfPqb7e
1E6NuFjCi27W5zoXg8TRdcSRq84zJeBW3k
1PitScNLyp2HCygzadCh7FveTnfmpPbfp8
1McVt1vMtCC7yn5b9wgX1833yCcLXzueeC
1M92tSqNmQLYw33fuBvjmeadirh1ysMBxK
1CQFwcjw1dwhtkVWBttNLDtqL7ivBonGPV
1LeBZP5QCwwgXRtmVUvTVrraqPUokyLHqe
1PgQVLmst3Z314JrQn5TNiys8Hc38TcXJu
1DBaumZxUkM4qMQRt2LVWyFJq5kDtSZQot
1Pie8JkxBT6MGPz9Nvi3fsPkr2D8q3GBc1
1ErZWg5cFCe4Vw5BzgfzB74VNLaXEiEkhk
1QCbW9HWnwQWiQqVo5exhAnmfqKRrCRsvW
1BDyrQ6WoF8VN3g9SAS1iKZcPzFfnDVieY
1HduPEXZRdG26SUT5Yk83mLkPyjnZuJ7Bm
1GnNTmTVLZiqQfLbAdp9DVdicEnB5GoERE
1NWmZRpHH4XSPwsW6dsS3nrNWfL1yrJj4w
1HsMJxNiV7TLxmoF6uJNkydxPFDog4NQum
14oFNXucftsHiUMY8uctg6N487riuyXs4h
1CfZWK1QTQE3eS9qn61dQjV89KDjZzfNcv
1L2GM8eE7mJWLdo3HZS6su1832NX2txaac
1rSnXMr63jdCuegJFuidJqWxUPV7AtUf7
15JhYXn6Mx3oF4Y7PcTAv2wVVAuCFFQNiP
1JVnST957hGztonaWK6FougdtjxzHzRMMg
128z5d7nN7PkCuX5qoA4Ys6pmxUYnEy86k
12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
19EEC52krRUK1RkUAEZmQdjTyHT7Gp1TYT
1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps
1LhE6sCTuGae42Axu1L1ZB7L96yi9irEBE
1FRoHA9xewq7DjrZ1psWJVeTer8gHRqEvR


Ejemplo de ejecucion:

./keyhunt -m address -f tests/1to32.txt -r 1:FFFFFFFF

Se especifica el rango de búsqueda del 1 al FFFFFFFF siempre en hexadecimal con -r 1:FFFFFFFF en este caso se especifica ese rango porque sabemos a priori que las address en la lista se encuentran en ese rango indicado, por que fueron address de puzzles anteriores y ya fueron resueltos.

Ejemplo de la salida:

[+] Version 0.1.20210328
[+] Setting mode address
[+] Opening file tests/1to32.txt
[+] Setting search for btc adddress
[+] Allocating memory for 32 elements: 0.00 MB
[+] Initializing bloom filter for 32 elements.
[+] Loading data to the bloomfilter
[+] Bloomfilter completed
[+] Sorting data
[+] 32 values were loaded and sorted
Thread 0 : Setting up base key: 0000000000000000000000000000000000000000000000000000000000000001
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000001
pubkey: 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
address: 1BgGZ9tcN4rm9KBzDn7KprQz87SZ26SAMH
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000003
pubkey: 02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9
address: 1CUNEBjYrCn2y1SdiUMohaKUi4wpP326Lb
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000007
pubkey: 025cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc
address: 19ZewH8Kk1PDbSNdJ97FP4EiCjTRaZMZQA
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000008
pubkey: 022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a01
address: 1EhqbyUMvvs7BfL8goY6qcPbD6YKfPqb7e
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000015
pubkey: 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5
address: 1E6NuFjCi27W5zoXg8TRdcSRq84zJeBW3k
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000031
pubkey: 03f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530
address: 1PitScNLyp2HCygzadCh7FveTnfmpPbfp8
(Output omitted)


metodo rmd160

Todas las address lagacy (Estas empiezan con 1) se pueden buscar también por su hash rmd160 previo al ser convertidas en base58

ejemplo del archivo de entrada:

751e76e8199196d454941c45d1b3a323f1433bd6
7dd65592d0ab2fe0d0257d571abf032cd9db93dc
5dedfbf9ea599dd4e3ca6a80b333c472fd0b3f69
9652d86bedf43ad264362e6e6eba6eb764508127
8f9dff39a81ee4abcbad2ad8bafff090415a2be8
f93ec34e9e34a8f8ff7d600cdad83047b1bcb45c
e2192e8a7dd8dd1c88321959b477968b941aa973
dce76b2613052ea012204404a97b3c25eac31715
7d0f6c64afb419bbd7e971e943d7404b0e0daab4
d7729816650e581d7462d52ad6f732da0e2ec93b
f8c698da3164ef8fa4258692d118cc9a902c5acc
85a1f9ba4da24c24e582d9b891dacbd1b043f971
f932d0188616c964416b91fb9cf76ba9790a921e
97f9281a1383879d72ac52a6a3e9e8b9a4a4f655
fe7c45126731f7384640b0b0045fd40bac72e2a2
7025b4efb3ff42eb4d6d71fab6b53b4f4967e3dd
b67cb6edeabc0c8b927c9ea327628e7aa63e2d52
ad1e852b08eba53df306ec9daa8c643426953f94
ebfbe6819fcdebab061732ce91df7d586a037dee
b907c3a2a3b27789dfb509b730dd47703c272868
29a78213caa9eea824acf08022ab9dfc83414f56
7ff45303774ef7a52fffd8011981034b258cb86b
d0a79df189fe1ad5c306cc70497b358415da579e
0959e80121f36aea13b3bad361c15dac26189e2f
2f396b29b27324300d0c59b17c3abc1835bd3dbb
bfebb73562d4541b32a02ba664d140b5a574792f
0c7aaf6caa7e5424b63d317f0f8f1f9fa40d5560
1306b9e4ff56513a476841bac7ba48d69516b1da
5a416cc9148f4a377b672c8ae5d3287adaafadec
d39c4704664e1deb76c9331e637564c257d68a08
d805f6f251f7479ebd853b3d0f4b9b2656d92f1d
9e42601eeaedc244e15f17375adb0e2cd08efdc9


Linea de busqueda:

./keyhunt -m rmd160 -f tests/1to32.rmd -r 1:FFFFFFFF -l compress

En este ejemplo anterior sabemos que las direcciones están comprimidas (Existen adress descomprimidas y comprimidas) esto se debe a que provienen de un public compress o compacto o sin compactar eso lo veremos en otro ejemplo mas adelante.

Ejemplo de salida:

[+] Version 0.1.20210328
[+] Setting mode rmd160
[+] Search compress only
[+] Opening file tests/1to32.rmd
[+] Allocating memory for 32 elements: 0.00 MB
[+] Initializing bloom filter for 32 elements.
[+] Loading data to the bloomfilter
[+] Bloomfilter completed
[+] Sorting data
[+] 32 values were loaded and sorted
Thread 0 : Setting up base key: 0000000000000000000000000000000000000000000000000000000000000001HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000001
pubkey: 0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000003
pubkey: 02f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000007
pubkey: 025cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000008
pubkey: 022f01e5e15cca351daff3843fb70f3c2f0a1bdd05e5af888a67784ef3e10a2a01
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000015
pubkey: 02352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5
HIT!! PrivKey: 0000000000000000000000000000000000000000000000000000000000000031
(Output omited)



metodo xpoint

Este metodo permite hacer lo mismo que antes pero busca exclusivamente el valor X de la clave publica, saltándose los costosos pasos de el hash sha256, hash rmd160 y el base58 encode.

Ejemplo del archivo de entrada:

034eee474fe724cb631d19f24934e88016e4ef2aee80d086621d87d7f6066ff860 # - 453856235784
0274241b684e7c31e7933510b510aa14de9ac88ec3635bdd35a3bcf1d16da210be # + 453856235784
03abc6aff092b9a64bf69e00f4ec7a8b7ca51cfc6656732cbbc9f5674925b88609 # - 529328067324
034f4fe33b02c202b732d278f90eedc635af6f3be8a93c8d1cb0a01f6399aab2a4 # + 529328067324
03716ff57705e6446ac3e217c8c8bd9e9c8e58547457a6fe93ac254c37fd48afcb # - 14711740067
02ffa0769b0459c64b41f59f93495063ae031de0b846180bee37f921f20e141f60 # + 14711740067
03de1df5d801bbd5e7d86577bf14950f732fd41e586945d06d19e0fdea41a37d62 # - 549755814000
038d3711fd681e26c05b2f0cd423fa596e15054024e40add24a93bfa0c630531f1 # + 549755814000
03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4 # target



El primer valor es la llave publica comprimida o compacta, el segundo valor es un offset, esto es debido a que podemos crear varias copias de una llave publica a diferentes distancia de la misma, tal vez no conoceremos el valor de la privatekeys pero si podemos realizar varias operaciones matemáticas con los valores de las llaves publicas en este caso son valores que se encuentran sumándole o restándole otras llaves publicas con valores ya conocidos, en caso de encontrar alguna de las copias solo es cuestión de hacer sumas o restas para encontrar el valor de la llave original.

Ejemplo de lineal de ejecución:

./keyhunt -m xpoint -f tests/substracted40.txt -n 65536 -t 4 -b 40

En este caso especificamos que el area de busqueda sea en el bit numero 40 ya que los valores mostrados fueron estrados o sumados apartir del publickey del puzzle numero 40.

Ejemplo de salida:

[+] Version 0.1.20210330a
[+] Setting mode xpoint
[+] Setting 4 threads
[+] Min range: 8000000000
[+] Max range: ffffffffff
[+] Opening file tests/substracted40.txt
[+] Allocating memory for 6003 elements: 0.11 MB
[+] Initializing bloom filter for 6003 elements.
[+] Loading data to the bloomfilter
[+] Bloomfilter completed
[+] Sorting data
[+] 6003 values were loaded and sorted
Thread 3 : Setting up base key: 0000000000000000000000000000000000000000000000000000008001d00000
Thread 0 : Setting up base key: 00000000000000000000000000000000000000000000000000000080025b0000
HIT!! PrivKey: 000000000000000000000000000000000000000000000000000000800258a2ce
pubkey: 0274241b684e7c31e7933510b510aa14de9ac88ec3635bdd35a3bcf1d16da210be
Thread 1 : Setting up base key: 0000000000000000000000000000000000000000000000000000008002910000^C


Este es un ejemplo basico para obtener la llave privada orignal tenemos que sumarle a 800258a2ce hexadecimal el valor de + 453856235784 (decimal) en este caso el resultado es E9AE4933D6

El puzzle por ser resulto actualmente es de 120 bits y he utilizado este método y otros mas aun sin tener suerte aun

Metodo pub2rmd

Este método lo que hace es buscar por fuerza bruta la llave publica de address o hashes específicos, esto es util por que de conocer la llave publica de una dirección de los puzzles de 64, 65 y varios menores que 100 bits podremos fácilmente resolverlos.

La ventaja es que puedes puedes buscar al mismo tiempo la llave publica de todas las direcciones sin clave publica conocida.
La desventaja es que tiene la misma complejidad de encontrar una clave privada de 256 bits (prácticamente imposible en nuestro tiempo de vida)

Ejemplo de entrada:

3ee4133d991f52fdf6a25c9834e0745ac74248a4
20d45a6a762535700ce9e0b216e31994335db8a5
739437bb3dd6d1983e66629c5f08c70e52769371
e0b8a2baee1b77fc703455f39d51477451fc8cfc
61eb8a50c86b0584bb727dd65bed8d2400d6d5aa
f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8
bf7413e8df4e7a34ce9dc13e2f2648783ec54adb
105b7f253f0ebd7843adaebbd805c944bfb863e4
9f1adb20baeacc38b3f49f3df6906a0e48f2df3d
86f9fea5cdecf033161dd2f8f8560768ae0a6d14
783c138ac81f6a52398564bb17455576e8525b29
35003c3ef8759c92092f8488fca59a042859018c
67671d5490c272e3ab7ddd34030d587738df33da
351e605fac813965951ba433b7c2956bf8ad95ce
20d28d4e87543947c7e4913bcdceaa16e2f8f061
24cef184714bbd030833904f5265c9c3e12a95a2
7c99ce73e19f9fbfcce4825ae88261e2b0b0b040
c60111ed3d63b49665747b0e31eb382da5193535
fbc708d671c03e26661b9c08f77598a529858b5e
38a968fdfb457654c51bcfc4f9174d6ee487bb41
5c3862203d1e44ab3af441503e22db97b1c5097e
9978f61b92d16c5f1a463a0995df70da1f7a7d2a
6534b31208fe6e100d29f9c9c75aac8bf06fbb38
463013cd41279f2fd0c31d0a16db3972bfffac8d
c6927a00970d0165327d0a6db7950f05720c295c
2da63cbd251d23c7b633cb287c09e6cf888b3fe4
578d94dc6f40fff35f91f6fba9b71c46b361dff2
7eefddd979a1d6bb6f29757a1f463579770ba566
c01bf430a97cbcdaedddba87ef4ea21c456cebdb


./keyhunt -m pub2rmd -f tests/puzzleswopublickey.txt -q

Ejemplo de salida:

[+] Version 0.1.20210331
[+] Setting mode pub2rmd
[+] Set quiet thread output
[+] Opening file tests/puzzleswopublickey.txt
[+] Allocating memory for 29 elements: 0.00 MB
[+] Initializing bloom filter for 29 elements.
[+] Loading data to the bloomfilter total: 0.00 MB
[+] Bloomfilter completed
[+] Sorting data
[+] 29 values were loaded and sorted
Total 76546048 keys in 90 seconds: 850511 keys/s


metodo bsgs

Las siglas de este método son por baby step giant step y es un metodo bastate veloz para buscar llaves privadas. Ejemplo de entrada:

043ffa1cc011a8d23dec502c7656fb3f93dbe4c61f91fd443ba444b4ec2dd8e6f0406c36edf3d8a0dfaa7b8f309b8f1276a5c04131762c23594f130a023742bdde # 0000000000000000000000000000000000800000000000000000100000000000
046534b9e9d56624f5850198f6ac462f482fec8a60262728ee79a91cac1d60f8d6a92d5131a20f78e26726a63d212158b20b14c3025ebb9968c890c4bab90bfc69 # 0000000000000000000000000000000000800000000000000000200000000000


Linea de ejecucion:

./keyhunt -m bsgs -f tests/test120.txt -b 120


Ejemplo de salida:

[+] Version 0.1.20210328
[+] Setting mode BSGS
[+] Min range: 800000000000000000000000000000
[+] Max range: ffffffffffffffffffffffffffffff
[+] Opening file tests/test120.txt
[+] Added 2 points from file
[+] Bit Range 120
[+] Setting N up to 17592186044416.
[+] Init 1st bloom filter for 4194304 elements : 14.00 MB
[+] Init 2nd bloom filter for 209716 elements : 0.00 MB
[+] Allocating 128.0 MB for 4194304 aMP Points
[+] Precalculating 4194304 aMP points
[+] Allocating 3.00 MB for 209716 bP Points
[+] processing 4194304/4194304 bP points : 100 %
[+] Sorting 209716 elements
[+] Thread 0: 0000000000000000000000000000000000800000000000000000000000000000
[+] Thread 0 Key found privkey 0000000000000000000000000000000000800000000000000000100000000000
[+] Publickey 043ffa1cc011a8d23dec502c7656fb3f93dbe4c61f91fd443ba444b4ec2dd8e6f0406c36edf3d8a0dfaa7b8f309b8f1276a5c04131762c23594f130a023742bdde
[+] Thread 0: 0000000000000000000000000000000000800000000000000000100000000000
Total 17592186044416 keys in 30 seconds: 586406201480 keys/s
[+] Thread 0 Key found privkey 0000000000000000000000000000000000800000000000000000200000000000
[+] Publickey 046534b9e9d56624f5850198f6ac462f482fec8a60262728ee79a91cac1d60f8d6a92d5131a20f78e26726a63d212158b20b14c3025ebb9968c890c4bab90bfc69
All points were found


La ventaja de este metodo es que la velocidad del mismo esta dada por la cantidad de RAM, con algunos cuantos Gigabytes de RAM puedes igualar la velocidad de búsqueda de varias tarjetas de video potentes y en general la memoria RAM es mas barata que las Tarjetas de video, adicionalmente consume menos electricidad.

Llave publica del puzzle 120

02CEB6CBBCDBDF5EF7150682150F4CE2C6F4807B349827DCDBDD1F2EFA885A2630

Lineal de ejecución:

./keyhunt -m bsgs -f tests/120.txt -b 120 -R

El -b 120 es para indicar que el rango es el el bit 120 de 800000000000000000000000000000 a ffffffffffffffffffffffffffffff hexadecimal

y el -R es para que la búsqueda sea aleatoria.

Ejemplo buscando el privatekey a una valocidad de 5.2 Petakeys/s

./keyhunt -m bsgs -f tests/120.txt -b 120 -R -k 1024 -q -p ./bPfile.bin -t 6

Salida:

[+] Version 0.1.20210328
[+] Setting mode BSGS
[+] Min range: 800000000000000000000000000000
[+] Max range: ffffffffffffffffffffffffffffff
[+] Setting random mode.
[+] Setting k factor to 1024
[+] Set quiet thread output
[+] Setting 6 threads
[+] Opening file tests/120.txt
[+] Added 1 points from file
[+] Bit Range 120
[+] Setting N up to 17592186044416.
[+] Init 1st bloom filter for 4294967296 elements : 14722.00 MB
[+] Init 2nd bloom filter for 214748365 elements : 736.00 MB
[+] Allocating 0.0 MB for 4096 aMP Points
[+] Precalculating 4096 aMP points
[+] Allocating 3276.00 MB for 214748365 bP Points
[+] Reading 4294967296 bP points from file ./bPfile.bin
[+] processing 4294967296/4294967296 bP points : 100 %
[+] Sorting 214748365 elements
Total 157238958864990208 keys in 30 seconds: 5241298628833006 keys/s


Estoy por liberar una versión que funcionara de 3 a 5 veces mas rápido
También estoy probando utilizar el bloomfilter directamente en disco NVMe utilizando de 1 a 2 TB solo para ver que velocidad obtengo.
Y por ultimo estoy haciendo una versión POOL para poder compartir poder de computo y dividir el trabajo entre varios clientes esto obviamente dividiendo el balance en caso de encontrar los puzzles.


Saludos!
#3
Quisiera abrir el siguiente hilo para saber si es posible determinar la paridad de un punto en una curva Eliptica utilizada en criptografía.

Encontré un video en youtube donde un programador de C# afirma tener la formula para determinar si un punto dado es par o impar para una curva en especifico.

Tiene una pagina

:http://remon78eg.tk/curve/mod2/

Utiliza un valor P custom: 115792089237316195423570985008687907853269984665640564039457584007908834675927

El cual afirma que es un valor débil o vulnerable.

El usuario no revela mucho de su método o test de paridad de un punto o publickey.

Las preguntas aquí son las siguientes:
¿Qué tiene de débil o vulnerable su orden de la curva?
¿Cuál seria el test de paridad que se pueda implementar para determinar si un punto (X,Y) pertenece a una privatekey par o impar?

Saludos!
#4
Muy buen día a todos últimamente hablando con Kub0x sobre curvas elípticas me sugirió publicar aquí los rompecabezas existentes de bitcoin, hay aproximadamente 12 bitcoin en premios. Para los rompecabezas Importantes y algunos otros bitcoin para rompecabezas pequeños.

Los rompecabezas se puede abordar de varias formas, pero abordarlos por fuerza bruta es casi imposible a no ser que tengan mucha mucha mucha suerte (El tema de Fuerza bruta exclusiva no va a ser tratado aqui).

Estos rompecabezas fueron hechos con el propósito explicito de ser crackeados desde el 2015 y en caso de conseguirlo pueden tomar el bitcoin de premio que se encuentra ahi, ya que el autor para eso los creo, fueron creados cuando el bitcoin se cambiaba por  160 Dolares cada uno, hoy en dia cuesta cada uno mas de 40 Mil dólares

A continuación los rompecabezas en el siguiente formato:
#Numero de Bits ( Dirección public de bitcoin ) Monto actual de la cartera
Inicio del rango del privatekey
Fin del rango del privatekey
Llave publica en formato comprimido


Puzzles:


#120 bits ( 17s2b9ksz5y7abUm92cHwG8jEPCzK3dLnT ) 1.20000000 BTC
800000000000000000000000000000
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
02CEB6CBBCDBDF5EF7150682150F4CE2C6F4807B349827DCDBDD1F2EFA885A2630

#125 bits ( 1PXAyUB8ZoH3WD8n5zoAthYjN15yN5CVq5 ) 1.25000000 BTC

10000000000000000000000000000000
1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
0233709EB11E0D4439A729F21C2C443DEDB727528229713F0065721BA8FA46F00E

#130 bits ( 1Fo65aKq8s8iquMt6weF1rku1moWVEd5Ua ) 1.30000000 BTC
200000000000000000000000000000000
3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
03633CBE3EC02B9401C5EFFA144C5B4D22F87940259634858FC7E59B1C09937852

#135 bits ( 16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v ) 1.35000000 BTC
4000000000000000000000000000000000
7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
02145D2611C823A396EF6712CE0F712F09B9B4F3135E3E0AA3230FB9B6D08D1E16

#140 bits ( 1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo ) 1.40000000 BTC
80000000000000000000000000000000000
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
031F6A332D3C5C4F2DE2378C012F429CD109BA07D69690C6C701B6BB87860D6640

#145 bits ( 19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg ) 1.45000000 BTC
1000000000000000000000000000000000000
1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
03AFDDA497369E219A2C1C369954A930E4D3740968E5E4352475BCFFCE3140DAE5

#150 bits ( 1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy ) 1.50000000 BTC
20000000000000000000000000000000000000
3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
03137807790EA7DC6E97901C2BC87411F45ED74A5629315C4E4B03A0A102250C49

#155 bits ( 1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ ) 1.55000000 BTC
400000000000000000000000000000000000000
7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
035CD1854CAE45391CA4EC428CC7E6C7D9984424B954209A8EEA197B9E364C05F6

#160 bits ( 1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv )  1.60000793 Bitcoin
8000000000000000000000000000000000000000
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
02E0A8B039282FAF6FE0FD769CFBC4B6B4CF8758BA68220EAC420E32B91DDFA673



Para quienes piensen  abordar el puzzle por fuerza bruta, estos son mas o menos los tiempos estimados para escanear el rango completo de acuerdo a la velocidad conseguida:

Puzzle 120 @ 1 Terakeys/s :     21074771622667996 años
Puzzle 120 @ 1 Petakeys/s :     21074771622667 años
Puzzle 120 @ 1 Exakeys/s :      21074771622 años
Puzzle 120 @ 1 Zettakeys/s :    21074771 años
Puzzle 120 @ 1 Yottakeys/s :    21074 años
Puzzle 125 @ 1 Terakeys/s :     674392691925375886 años
Puzzle 125 @ 1 Petakeys/s :     674392691925375 años
Puzzle 125 @ 1 Exakeys/s :      674392691925 años
Puzzle 125 @ 1 Zettakeys/s :    674392691 años
Puzzle 125 @ 1 Yottakeys/s :    674392 años
Puzzle 130 @ 1 Terakeys/s :     21580566141612028377 años
Puzzle 130 @ 1 Petakeys/s :     21580566141612028 años
Puzzle 130 @ 1 Exakeys/s :      21580566141612 años
Puzzle 130 @ 1 Zettakeys/s :    21580566141 años
Puzzle 130 @ 1 Yottakeys/s :    21580566 años
Puzzle 135 @ 1 Terakeys/s :     690578116531584908094 años
Puzzle 135 @ 1 Petakeys/s :     690578116531584908 años
Puzzle 135 @ 1 Exakeys/s :      690578116531584 años
Puzzle 135 @ 1 Zettakeys/s :    690578116531 años
Puzzle 135 @ 1 Yottakeys/s :    690578116 años
Puzzle 140 @ 1 Terakeys/s :     22098499729010717059011 años
Puzzle 140 @ 1 Petakeys/s :     22098499729010717059 años
Puzzle 140 @ 1 Exakeys/s :      22098499729010717 años
Puzzle 140 @ 1 Zettakeys/s :    22098499729010 años
Puzzle 140 @ 1 Yottakeys/s :    22098499729 años
Puzzle 145 @ 1 Terakeys/s :     707151991328342945888372 años
Puzzle 145 @ 1 Petakeys/s :     707151991328342945888 años
Puzzle 145 @ 1 Exakeys/s :      707151991328342945 años
Puzzle 145 @ 1 Zettakeys/s :    707151991328342 años
Puzzle 145 @ 1 Yottakeys/s :    707151991328 años
Puzzle 150 @ 1 Terakeys/s :     22628863722506974268427923 años
Puzzle 150 @ 1 Petakeys/s :     22628863722506974268427 años
Puzzle 150 @ 1 Exakeys/s :      22628863722506974268 años
Puzzle 150 @ 1 Zettakeys/s :    22628863722506974 años
Puzzle 150 @ 1 Yottakeys/s :    22628863722506 años
Puzzle 155 @ 1 Terakeys/s :     724123639120223176589693541 años
Puzzle 155 @ 1 Petakeys/s :     724123639120223176589693 años
Puzzle 155 @ 1 Exakeys/s :      724123639120223176589 años
Puzzle 155 @ 1 Zettakeys/s :    724123639120223176 años
Puzzle 155 @ 1 Yottakeys/s :    724123639120223 años
Puzzle 160 @ 1 Terakeys/s :     23171956451847141650870193314 años
Puzzle 160 @ 1 Petakeys/s :     23171956451847141650870193 años
Puzzle 160 @ 1 Exakeys/s :      23171956451847141650870 años
Puzzle 160 @ 1 Zettakeys/s :    23171956451847141650 años
Puzzle 160 @ 1 Yottakeys/s :    23171956451847141 años


Si tienen alguna duda favor de comentarla en este hilo.

He creado un canal privado de Telegram, si alguno gusta discutir el tema ahí, favor de enviarme mensaje privado a https://t.me/albertobsd y si lo considero oportuno los agregare al grupo.

Saludos!
#5
Ok, veamos necesito una forma eficiente de ordenar un archivo de de 100 GB, Cada registro del archivo son 36 Bytes en binario.

Usualmente lo hacia con archivos pequeños 10 o 5 GB pero en RAM. Esto con el algoritmo Introsort y es bastante eficiente, pero ahora estoy utilizando el mismo método pero en Disco duro ya que el archivo es muy grande, Lo que estoy haciendo es leer los registros del disco, cargarlos en memoria, compararlos y escribir en disco en caso de que necesiten ser ordenados. Este proceso es muy lento directo en el disco duro.

Podría tratar de dividir el proceso he ir cargando de 10 en 10 GB en RAM u otra cantidad ordenarlos en memoria y seguir con los demás pedazos, sin embargo el problema es ordenar entre pedazos separados.

El proceso de generación de registros es aleatorio y no se en que orden se generaran los registros, quiero hacer este proceso lo mas eficiente y rápido posible, ya que si funciona este archivo tendré que generar un archivo similar de 500 o 1000 GB. No tengo problemas de Espacio en disco.

¿Alguna idea adicional a hacerlo directo desde el disco duro?



Edit:

Ayer miestras publicaba este teme tambien pense en la solucion, pero no queria publicarla hasta implementarla.

Dado que la generación de los registros es aleatoria y es uniforme entre el rango de A a B entonces se me ocurre que una vez generado el archivo de 100 GB, dividir el rango de A a B en subrangos manejables en RAM
por decil algo tengo los siguientes rangos para registros de 32 bytes:

From 0000000000000000000000000000000000000000000000000000000000000000 to 0ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc
From 0ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc to 1999999999999999999999999999999999999999999999999999999999999998
From 1999999999999999999999999999999999999999999999999999999999999998 to 2666666666666666666666666666666666666666666666666666666666666664
From 2666666666666666666666666666666666666666666666666666666666666664 to 3333333333333333333333333333333333333333333333333333333333333330
From 3333333333333333333333333333333333333333333333333333333333333330 to 3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc
From 3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc to 4cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc8
From 4cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc8 to 5999999999999999999999999999999999999999999999999999999999999994
From 5999999999999999999999999999999999999999999999999999999999999994 to 6666666666666666666666666666666666666666666666666666666666666660
From 6666666666666666666666666666666666666666666666666666666666666660 to 733333333333333333333333333333333333333333333333333333333333332c
From 733333333333333333333333333333333333333333333333333333333333332c to 7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8
From 7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8 to 8cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc4
From 8cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc4 to 9999999999999999999999999999999999999999999999999999999999999990
From 9999999999999999999999999999999999999999999999999999999999999990 to a66666666666666666666666666666666666666666666666666666666666665c
From a66666666666666666666666666666666666666666666666666666666666665c to b333333333333333333333333333333333333333333333333333333333333328
From b333333333333333333333333333333333333333333333333333333333333328 to bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff4
From bffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff4 to ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc0
From ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc0 to d99999999999999999999999999999999999999999999999999999999999998c
From d99999999999999999999999999999999999999999999999999999999999998c to e666666666666666666666666666666666666666666666666666666666666658
From e666666666666666666666666666666666666666666666666666666666666658 to f333333333333333333333333333333333333333333333333333333333333324
From f333333333333333333333333333333333333333333333333333333333333324 to ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff


Entonces buscamos en el archivo los valores que entren en alguno de los rango anteriores, se ordenan en RAM y se escriben en un archivo aparte. Una vez completado el proceso para todos los sub-rangos se unen los archivos en uno solo y se borra el archivo desordenado.

Esto se puede hacer así debido a que la distribución de los registros es uniforme en el rango original de A a B, en caso de que la data este sesgada y existan mas valores en un sub-rango dado es conveniente poner un limite de cantidad de registros leídos para que el mismo no sobrepase la cantidad de RAM.

Saludos!
#6
Pues nada compañeros esta próxima semana cumplo 15 años registrado en el foro.

Yo se que tengo mas años viendo el foro, sin embargo hasta ese momento abrí mi cuenta.

Quiero agradecer a todos los miembros de este foro, a los que ya no están y a los que aun siguen. En este foro he aprendido mucho, de muchos temas distintos, aunque sea un poco de todo, estoy muy agradecido.

Desde ya muchas GRACIAS

Saludos!
#7
Recientemente me interesa ese tipo de temas otra vez, he aprendido mucho y me gustaría compartirlo con ustedes.

Si no saben de que va el tema aquí dejo unos links.

Block cipher mode of operation
https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation

Wikipedia Padding oracle attack
https://en.wikipedia.org/wiki/Padding_oracle_attack

Padding oracle attack
https://robertheaton.com/2013/07/29/padding-oracle-attack/

Este tipo de Ataque tiene ciertas condiciones iniciales para ser llevado acabo.

  • El cliente solo puede saber si su paquete fue aceptado o no.
    Esto es debido al check que hace el servidor sobre el mensaje recibido

  • El servidor no Cambia de KEY utilizada durante el proceso de cifrado y descifrado.
    Esto es debido a una mala implementación, ya que el servidor debería de renovar el KEY cada X tiempo y con cada cliente distinto.

  • El servidor tiene algún leak de información ya sea por error o mediante otro tipo de ataque.

  • El cliente solo podrá descifrar Una parte de la información, excepto por el Bloque inicial


    Dejo a continuación una imagen de prueba y el código, proximamente subire un video hablando del tema.




    [youtube=640,360]https://www.youtube.com/watch?v=GTl4ytJ3jBU[/youtube]

    Codigo, este codigo ejemplifica el cliente y servidor mediante un hilo distinto, lo hice de esta manera para no complicarme con el protocolo en RED de los mismo, se puede hacer sin hilos, y solo con llamadas a funcion, pero la idea es garantizar que el cliente no tiene acceso al servidor.



    /*
    Desarollado por AlbertoBSD
    email alberto.bsd@gmail.com
    g++ -O3 -o opk_example opk_example.c -Wint-to-pointer-cast  -pthread
    */

    #include <time.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include<pthread.h>
    #include<unistd.h>
    #include"ctaes/ctaes.c"

    #define AES_BLOCKSIZE 16

    struct timespec tim, tim2,sim,sim2;

    void crear_server();
    char *tohex(char *ptr,int length);
    void *process_server(void *vargp);

    int MyCBCEncrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out);
    int MyCBCDecrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out);

    /* Values between Server and client */
    int values_do;
    int values_pad;
    int values_length;
    int values_leaked;
    char *values_enc;
    char *values_leak;

    pthread_mutex_t mtx_values;  //Mutex for those values

    int main(){
     /*
       Set global values;
     */
     tim.tv_sec = 0;
     tim.tv_nsec = 50000;

     sim.tv_sec = 0;
     sim.tv_nsec = 50000;
     values_do = 0;
     values_pad = 0;
     values_length = 0;
     values_leaked = 0;
     values_enc = (char*) malloc(48);
     values_leak = (char*) malloc(48);
     crear_server();  //create child "server"

     //This main process is the client
     int i,j,k,entrar;
     char *secret,*temp,*try_enc;
     char *decrypted;
     unsigned char GUESS;
     secret = (char*) malloc(48);
     try_enc = (char*) malloc(48);
     decrypted = (char*) malloc(16);
     memset(decrypted,0,16);
     do  {  
       sleep(1);
     }while(values_leaked==0); //We need to wait to the leaked data

     memcpy(secret,values_leak,48);
     
     temp = tohex(secret,48);
     printf("process_client: leaked is %s\n",temp);
     free(temp);
     i = 0;
     j = 0;
     while(i < 16)  {
       memcpy(try_enc,secret,32);
       
       pthread_mutex_lock(&mtx_values);
       switch(values_do)  {
         case 0:
           GUESS = j;
           decrypted[15-i] = GUESS;
           for(k = 0; k <= i;k++)  {
             try_enc[15-k] = try_enc[15-k] ^ decrypted[15-k] ^ (unsigned char)(i+1);
           }
           
           values_do = 1;
           values_length = 32;
           memcpy(values_enc,try_enc,32);
         break;
         case 1:
         break;
         case 2:
           if(values_pad)  {
             i++;
             printf("Encontrado valor: %c : %.2x\n",GUESS,GUESS);
             j = 0;
           }
           else  {
             j++;
           }
           values_do = 0;
         break;
       }
       pthread_mutex_unlock(&mtx_values);
       nanosleep(&tim , &tim2);
     }
     printf("Decrypted data: %s\n",decrypted);
     
    }

    void *process_server(void *vargp)  {
     AES256_ctx ctx;
     FILE *urandom;
     const char *secret = "The password is: Ywgo/@g:2$0Qsz<";
     char *key,*dec,*enc,*iv,*temp;
     int length,i,pad_valid,outlen;
     unsigned char pad;
     key = (char*) malloc(32);
     dec = (char*) malloc(48);
     enc = (char*) malloc(48);
     iv  = (char*) malloc(16);
     urandom = fopen("/dev/urandom","rb");
     fread(key,1,32,urandom);
     fread(iv,1,16,urandom);
     fclose(urandom);
     
     AES256_init(&ctx,(const unsigned char*) key);
     
     /* LEAK THE secret */
     pthread_mutex_lock(&mtx_values);
     memset(enc,0,48);


     outlen = MyCBCEncrypt(&ctx, (const unsigned char*) iv, (const unsigned char*) secret, strlen(secret), true, (unsigned char*) enc);

     memcpy(values_leak,enc,outlen);
     values_leaked = 1;
     pthread_mutex_unlock(&mtx_values);
     /*END LEAK*/
     
     do  {
       nanosleep(&sim , &sim2);
       pthread_mutex_lock(&mtx_values);
       if(values_do == 1)  {
         length = values_length;
         pad_valid = 0;
         if(length <= 48)  {
           memcpy(enc,values_enc,length);

           outlen = MyCBCDecrypt(&ctx,( const unsigned char*) iv, (const unsigned char*) enc, length, true, (unsigned char*) dec);
           if(outlen > 0)  {
             pad_valid =  1;
             printf("Decrypted data seems legit : %i bytes\n",outlen);
             temp = tohex(dec,length);
             printf("Decrypted data %s\n",temp);
             free(temp);
           }
           else  {
             printf("Decrypted data doesnt seems legit\n",outlen);
             temp = tohex(dec,length);
             printf("Decrypted data %s\n",temp);
             free(temp);
           }
         }
         values_do = 2;
         values_pad = pad_valid;
       }
       pthread_mutex_unlock(&mtx_values);
     }while(1);
     pthread_exit(NULL);
    }

    void crear_server()  {
     int s;
     pthread_t tid;
     pthread_attr_t attr;
     s = pthread_attr_init(&attr);
     if (s != 0)  {
       perror("pthread_attr_init");
       exit(6);
     }
     s = pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
     if(s != 0)  {
       perror("pthread_attr_setstacksize");
       exit(8);
     }
     s = pthread_create(&tid,&attr,process_server,NULL);
     if(s != 0)  {
       perror("pthread_create");
     }
     pthread_attr_destroy(&attr);
    }

    char *tohex(char *ptr,int length){
     char *buffer;
     int offset = 0;
     unsigned char c;
     buffer = (char *) malloc((length * 2)+1);
     for (int i = 0; i <length; i++) {
     c = ptr[i];
     sprintf((char*) (buffer + offset),"%.2x",c);
     offset+=2;
     }
     buffer[length*2] = 0;
     return buffer;
    }


    int MyCBCDecrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out)
    {
     int written = 0;
     bool fail = false;
     const unsigned char* prev = iv;
     if (!data || !size || !out)
       return 0;
     if (size % AES_BLOCKSIZE != 0)
       return 0;
     while (written != size) {
       AES256_decrypt(ctx, 1, out, data + written);
       for (int i = 0; i != AES_BLOCKSIZE; i++)
         *out++ ^= prev[i];
       prev = data + written;
       written += AES_BLOCKSIZE;
     }
     if (pad) {
       unsigned char padsize = *--out;
       fail = !padsize | (padsize > AES_BLOCKSIZE);
       padsize *= !fail;
       for (int i = AES_BLOCKSIZE; i != 0; i--)
         fail |= ((i > AES_BLOCKSIZE - padsize) & (*out-- != padsize));
       written -= padsize;
     }
     return written * !fail;
    }

    int MyCBCEncrypt(AES256_ctx *ctx, const unsigned char iv[AES_BLOCKSIZE], const unsigned char* data, int size, bool pad, unsigned char* out)
    {
     int written = 0;
     int padsize = size % AES_BLOCKSIZE;
     unsigned char mixed[AES_BLOCKSIZE];

     if (!data || !size || !out)
       return 0;

     if (!pad && padsize != 0)
       return 0;

     memcpy(mixed, iv, AES_BLOCKSIZE);

     // Write all but the last block
     while (written + AES_BLOCKSIZE <= size) {
       for (int i = 0; i != AES_BLOCKSIZE; i++)
         mixed[i] ^= *data++;
       AES256_encrypt(ctx, 1, out + written, mixed);
       memcpy(mixed, out + written, AES_BLOCKSIZE);
       written += AES_BLOCKSIZE;
     }
     if (pad) {
       // For all that remains, pad each byte with the value of the remaining
       // space. If there is none, pad by a full block.
       for (int i = 0; i != padsize; i++)
         mixed[i] ^= *data++;
       for (int i = padsize; i != AES_BLOCKSIZE; i++)
         mixed[i] ^= AES_BLOCKSIZE - padsize;
       AES256_encrypt(ctx, 1, out + written, mixed);
       written += AES_BLOCKSIZE;
     }
     return written;
    }



    Saludos!
#8
Seguridad / Como proteger una cartera Bitcoin
18 Noviembre 2020, 01:45 AM
Como proteger una cartera Bitcoin

No sabemos qué pasará en el futuro, es decir no sabemos si nos robaran la cartera o la perderemos en algún USB y alguien la encontrara. Tampoco sabemos la cantidad de poder de computo que existira.

Pero además de tener cifrada nuestra cartera con un buen passphrase de más de 40 caracteres, se puede lograr una mejor seguridad, para en el caso de que sea robada sea inviable que por medio de fuerza bruta directo contra el passphrase.

Nuestra Cartera está protegida con el resultado de un hash sha512 derivado N veces a partir de nuestro Passphrase y un salt.

Es decir:

(key,IV) = PBKDF2_algo("sha512",passphrase+salt,N);

Normalmente el cliente bitcoin-core calcula ese N de tal forma que la Operación en total no lleve más de 1 Segundo

¿Por que? ¿Por que ponérsela fácil a los crackers de wallets?

Se puede editar el código fuente del bitcoin-core de tal forma que cuando nosotros cambiemos el passphrase este utilice un número N tal que N el proceso completo de PBKDF2_algo lleve al menos uno o dos minutos por passphare, es un pequeño precio de espera. Y el resultado será sumamente desalentador para quien se robe o encuentre la cartera.

¿Como hacer esta modificacion?

Si revisamos la versión estable y actual al dia de hoy, el bitcoin core 0.20 el archivo wallet.cpp tiene la solución:

https://github.com/bitcoin/bitcoin/blob/0.20/src/wallet/wallet.cpp En la linea 322 tenemos lo siguiente:

bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
{
   bool fWasLocked = IsLocked();

   {
       LOCK(cs_wallet);
       Lock();

       CCrypter crypter;
       CKeyingMaterial _vMasterKey;
       for (MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
       {
           if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
               return false;
           if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
               return false;
           if (Unlock(_vMasterKey))
           {
               int64_t nStartTime = GetTimeMillis();
               crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
               pMasterKey.second.nDeriveIterations = static_cast<unsigned int>(pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime))));

               nStartTime = GetTimeMillis();
               crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
               pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + static_cast<unsigned int>(pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime)))) / 2;

               if (pMasterKey.second.nDeriveIterations < 25000)
                   pMasterKey.second.nDeriveIterations = 25000;

               WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);

               if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                   return false;
               if (!crypter.Encrypt(_vMasterKey, pMasterKey.second.vchCryptedKey))
                   return false;
               WalletBatch(*database).WriteMasterKey(pMasterKey.first, pMasterKey.second);
               if (fWasLocked)
                   Lock();
               return true;
           }
       }
   }

   return false;
}


Y solo tendria que quedar de la siguiente manera:

bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
{
   bool fWasLocked = IsLocked();

   {
       LOCK(cs_wallet);
       Lock();

       CCrypter crypter;
       CKeyingMaterial _vMasterKey;
       for (MasterKeyMap::value_type& pMasterKey : mapMasterKeys)
       {
           if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
               return false;
           if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, _vMasterKey))
               return false;
           if (Unlock(_vMasterKey))
           {
               pMasterKey.second.nDeriveIterations = 133707331;

               WalletLogPrintf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);

               if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
                   return false;
               if (!crypter.Encrypt(_vMasterKey, pMasterKey.second.vchCryptedKey))
                   return false;
               WalletBatch(*database).WriteMasterKey(pMasterKey.first, pMasterKey.second);
               if (fWasLocked)
                   Lock();
               return true;
           }
       }
   }

   return false;
}


Si quitamos todo lo relacionado con el calculo del tiempo y agregamos la linea:

pMasterKey.second.nDeriveIterations = 133707331;

En mi caso con el bitcoin-core oficial recompilado y con un procesador Intel Xeon CPU E3-1271 v3 @ 3.60GHz cambiar el passphrase toma alrededor de un minuto

Saludos!

#9

Como crackear una cartera bitcoin. (Teoria y practica).

Bueno esta investigación comenzó a manera de broma y solo por hobby. En las platicas que tenemos en la comunidad de elhacker.net en Telegram ( https://t.me/elhackerdotnet )

Se menciono hace tiempo la existencia de una  cartera de bitcoin con 69 Mil BTC, al tipo de cambio actual hoy 4 de Noviembre de 2020 serian unos 995 millones de dólares, entre bromas se menciono que teníamos que crackearla con algún computador cuántico.

En fin, el proceso "normal" para abrir una cartera cifrada utilizando las aplicaciones oficiales de Bitcoin-Core es el siguiente.

Primero cargamos la cartera

bitcoin-cli loalwallet "wallet.dat"

"wallet.dat" es un archivo que debe de existir en el directorio ~/.bitcoin/wallets/

Se puede llamar de otro modo, el punto es que debe de exisitir en ese path

Segundo desbloqueamos la cartera con nuestra passphrase o mas comúnmente contraseña

bitcoin-cli walletpassphrase "passphrase o password" 60

Entre comillas tenemos nuestro password y el 60 a continuación indica que desbloqueamos la cartera por 60segundos

Si el password es correcto no marcara error, de lo contrario lo indicará.

error code: -14
error message:
Error: The wallet passphrase entered was incorrect.


Ahora la forma lenta e ineficiente de intentar crackearla por fuerza fruta probando directamente distintos passphrase desde la misma terminal.
Sigue siendo lento incluso aunque se utilice algún script bash por que pasar del bash al programa y de regreso es ineficiente.

Necesitamos saber que hace internamente la aplicación, para tratar de reproducirlo en un programa en C y ejecutarlo por aparte posiblemente con multihilo para mejorar la eficiencia

¿Que hace el bitcoin core con nuestro passphrase?

Nuestro passphrase es combinado con un salt que se encuentra almacenado en el archivo, mediante un algoritmo estilo PBKDF y con mas de 25000 iteraciones generan un hash sha512.

De estos 64 bytes generados mediante PBKDF, se utilizan los primeros 32 bytes como KEY para inicializar el contexto de AES y los siguientes 16 bytes como IV para el algoritmo CBC

A este algoritmo AES256CBC se le pasa como parámetro para descifrar el mKey (master KEY) cifrado y se obtiene un mKey Descifrado

El master key ya descifrado se le hacen varias pruebas, se utiliza este valor como KEY para otros descifrados y en este caso como IV en todas las pruebas se utilizan 16 bytes del public Key de la cartera bitcoin obtenidos por una función interna llamada GetHash que desconozco que valores devuelva exactamente, solamente me limite a llamarla.

Y si el master key ya descifrado pasa todas las pruebas se almacena en memoria para sea utilizado en el futuro.

Fin de la triste Historia.  :silbar:

Resumen en pseudo codigo

El siguiente codigo en Pseudo C esta solo para representare que hace la aplicación internamente.

prekey = PBKDF(passphrase,IV, N Iteraciones,"sha512");
memcpy(KEY,prekey,32);
memcpy(IV,prekey+32,16);
aesctx = AES256_init(KEY);
if( AES256CBC_decrypt(aesctx,IV,ENC_mKey,DEC_mKEY) > 0) {
foreach(OthersENC as oENC) {
oCtx = AES256_init(DEC_mKEY);
if(!AES256CBC_decrypt(oCtx,IV_fromPublickey,oENC,dummy) > 0) {
return false;
}
}
return true;
}


Entonces si nuestro plan es un ataque por fuerza bruta podemos saltarnos el PBKDF que se ejecuta N Iteraciones (Mínimo 25000) y saltar directamente al Decrypt de AES.

Tenemos 2 opciones:

1.- Generar un par (KEY,IV) 48 bytes random o secuencial y empezar con el primer AES256CBC_decrypt y utilizar el valor generado para continuar con los AES256CBC_decrypt dentro del for.

2.- O generar solamente un KEY de 32 bytes random o secuencial y pasar directamente a los AES256CBC_decrypt dentro del For.

Asi con 32 bytes solo tenemos 1 de 115792089237316195423570985008687907853269984665640564039457584007913129639936 posibilidades de dar con la KEY correcto.
xD xD xD

Resultados vistos en la práctica.

Con la opción 1 solamente el 0.4% de los valores aleatorios generados pasaban el primer AES256CBC_decrypt posteriormente solo el 0.4% de esos valores pasaban el primer AES256CBC_decrypt dentro del FOR

Para la cartera que cree con el propósito de realizar las pruebas los challenge dentro del FOR eran sobre 500.

Sin embargo para la cartera lackeada con 69K BTC solo está disponible un solo challenge dentro del FOR, al ser solo dos AES256CBC_decrypt me dio bastantes KEY "Falsos positivos" aproximadamente uno de cada millón de valores random generados (KEY,IV) pasaban ambas pruebas

En conclusión

La aproximación por Fuerza Bruta a AES256CBC es improbable que funcione ojo, improbable no imposible, Tal vez en el futuro con mejor poder de computo disponible, o tal vez con Múltiples equipos trabajando de forma sincronizada con alguna RED tipo BOINC o algún tipo de BOTNET

Tengo el código utilizado para realizar este proceso, un poco de manera hardcodeada Ya que los Valores cifrados los saque directamente mediante Hexedit, si alguien esta interesado en la estructura del archivo no dude en comentarlo.

Saludos

Posdata
La cartera de 69K BTC fue vaciada por alguien el dia de ayer. 3 de Noviembre a las 3PM
https://twitter.com/albertobsd/status/1323752623510446080
https://decrypt.co/es/47133/wallet-de-bitcoin-con-955-millones-famosa-entre-hackers-se-acaba-de-vaciar?amp=1
#10
Anteriormente no me había fijado la salida del descifrado por AES 256 CBC con Pad habilitado.

Normalmente uno solo espera la data original descifrada, vamos que si ciframos la palabra "hola" esperamos de vuelta la misma palabra "hola" ya descifrada.

Cuando encriptas sin padding cada bloque del tamaño  "AES_BLOCKSIZE" devuelve la misma cantidad de bloques. Pero el cifrar con Padding agrega cierta cantidad mas de datos.

Por ejemplo si ciframos 32 bytes con AES256CBC con Padding nos devuelve un buffer con 48 bytes de data

Y cuando desciframos esos 48 bytes, nos devuelve la data original de 32 bytes + un buffer "sucio" es decir que hay mas datos en el buffer, en mi caso he comprobado que para este ejemplo siempre devuelve un buffer sucio de 16 bytes y cada uno de esos bytes tiene valor de uno.

Mi pregunta es ¿Es normal esto, o solo es la forma en la que trabaja la librería ctaes?

hice un programa que muestra que independientemente del key y del IV utilizados  siempre pasa lo mismo

albertobsd $ ./test_aes256cbc
key: fd792d4458dbc9bfee589482273ae061a37e24a72e95a0a5fba17109e4cb1daf
iv: 7d5559d5e50e340bb66618ceaad7ed1b
Data: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
len 48
cipher data 1117fcb2cbb27ee2f735ce4083d0aea743b51f6b7f61f59ce5a27a78bb5d454eab8b6a1733a5ad1d07b0b08ba1732e04
len 32
decipher data 414141414141414141414141414141414141414141414141414141414141414110101010101010101010101010101010
albertobsd $ ./test_aes256cbc
key: 1049354727fa2affd4410da40870f1757e211efeb96349b8576157c101fe5ab0
iv: 49547b6aac189b8487f60157d13185df
Data: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
len 48
cipher data e980ef82804a6fe5bec15dda0ad50064457c65259cd810055c38eb7c55e1d40071646c7c792e6d5a7ac6597057868267
len 32
decipher data 414141414141414141414141414141414141414141414141414141414141414110101010101010101010101010101010
albertobsd $ ./test_aes256cbc
key: 6d40ce0be48da5fcc7ede6531dae1b3613e5931a808e1ae99928ab74f74f3685
iv: ec1cebfa7894563a8329aa797610841c
Data: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
len 48
cipher data 395976ca9f00ace59ba64e8a1ee5dbaf55f45e786fada6520148d82a84c298e15b2854763a2fc82e7a62164936bf8f1f
len 32
decipher data 414141414141414141414141414141414141414141414141414141414141414110101010101010101010101010101010




De ser normal esto se podría tomar ese buffer sucio como una comprobación de que la key y el iv utilizados son los correctos?


Saludos
#11
Seguridad / Extraer MasterKey de cartera Bitcoin
29 Octubre 2020, 16:35 PM
Publico este tema aquí, ya que no se en qué sección queda mejor publicarlo.

Estoy intentando extraer la información Cifrada de una cartera bitcoin, en específico la información del Key para posteriormente intentar descifrarlo por algún ataque de fuerza bruta.

Quiero extraerla por que no quiero depender del bitcoin core ya que si se realiza el ataque por fuerza bruta mediante algún script bash o algun otro metodo NO compilado, el ataque puede ser realmente ineficiente.

También quiero brincarme algunos pasos innecesarios de funciones tipo rehash o PBKDF2 (key derivation) ya que aunque no consumen mucho CPU si quitan algunos miles de ciclos de procesamiento que a la larga pueden hacer aun mas eterno el proceso de crackeo.

Segun he leido la informacion del Key cifrado el salt y el numero de iteraciones esta contenida en un campo de 64 bytes del wallet.dat llamado mkey.

Segun vi en el siguiente Link:

https://bitcoin.stackexchange.com/questions/48070/format-of-mkey-field-in-encrypted-wallet-dat-file

La data contiene los siguientes campos:

mkey, nID, encrypted_key, salt, derivation_method, derivation_rounds, other_derivation_parameters

Citar
  • mkey - a size prefixed string denoting the start of the master key data.
  • nID - an integer whose purpose I have been unable to determine.
  • encrypted_key - a size prefixed buffer containing the encrypted master key.
  • salt - a size prefixed buffer containing the salt data used when encrypting the key.
  • derivation_method - an integer containing either 0 or 1 for the method used to encrypt the master key using the wallet password.
  • derivation_rounds – an integer containing the number of rounds used to encrypt the master key.
  • other_derivation_parameters
mkey es solo el ascii "mkey", se que el encrypted_key debe de ser de 32 bytes y el salt de 16, restando solo 12 bytes para los otros datos, sin embargo no estoy seguro del orden de los mismos.

Si vemos la siguiente imagen:





Vemos que ahí esta la data, escribí un pequeño programa que la encuentra y la extrae, pero no se en que orden este, con ver los datos de esta cartera y otras me doy cuenta de algunos datos que pueden ser números como los primeros 8 bytes después del mkey, pueden ser números, al igual que los últimos 4 antes de ckey.



Edit

Solucionado el master key cifrado son 48 bytes que se encuentran a un offset de -72 bytes de la primera coincidencia del string mkey.

Para esta cartera en cuestión el Master Key Cifrado es:

CEC646179A7F947349A0AA99EC7122B01F72BF18FFA4FDC760635D8C13109DA196D3DC802D5AABB23FA6C6AABA9A1DBB

Saludos

#12
Recientemente publique el tema:Como determina la función AES256CBCDecrypt una correcta desencriptación El cual esta relacionado con este de forma algo indirecta.

Todo esto viene del análisis que estoy realizando al código fuente del Bitcoin Core.

Hoy hablaré sobre la función BytesToKeySHA512AES la cual es una de las primeras que se utilizan cuando intentas desbloquear una cartera bitcoin protegida con un passphrase.

BytesToKeySHA512AES básicamente toma las passphrase ingresada + un salt proporcionado por el mismo archivo wallet.dat y los transforma en un (key, iv) para posteriormente utilizarlos como material para descifrar la llave cifrada.

El código fuente de BytesToKeySHA512AES, lo pueden encontrar en

https://github.com/bitcoin/bitcoin/blob/master/src/wallet/crypter.cpp 

Tiene 3 parámetros de entrada y 2 de salida
Entrada:
Salt
Passphrase
Count

Salida:
Key
IV

La parte interesante del código es la siguiente:

Código (c++) [Seleccionar]
    for(int i = 0; i != count - 1; i++)
        di.Reset().Write(buf, sizeof(buf)).Finalize(buf);


Básicamente obtiene el hash sha512 de si mismo (count -1) veces ya la que primera vez fue el hash sha512 de (passphrase + IV) como muestra el siguiente código:

Código (c++) [Seleccionar]
    di.Write((const unsigned char*)strKeyData.data(), strKeyData.size());
    di.Write(chSalt.data(), chSalt.size());
    di.Finalize(buf);


Posteriormente copia los primeros 32 bytes al Key y los siguientes 16 bytes al Vector IV

Si no están familiarizados con la sintaxis  del codigo anterior dejare un código en PHP ejemplificando lo que hace la función:

Código (php) [Seleccionar]
<?php
$salt 
"BBBBBBBBBBBBBBBB";
$passphrase "AAAAA";
$key_ ="";
$iv_ "";
BytesToKeySHA512AES($salt ,$passphrase,2,$key_$iv_ );

echo 
"Key:\n";
var_dump($key_);
echo 
"IV:\n";
var_dump($iv_);

function 
BytesToKeySHA512AES($chSalt,$strKeyData,$count,&$key,&$iv) {
$ctx hash_init('sha512');
hash_update($ctx,$strKeyData);
hash_update($ctx,$chSalt);
$buf hash_final($ctx,true);
$i 0;
while($i != $count -1) {

/* //Estas tres líneas básicamente se transforman en una simple llamada a hash
$ctx = hash_init('sha512');
hash_update($ctx,$buf);
$buf = hash_final($ctx,true);
*/
$buf hash('sha512',$buf,true);
$i++;
}
echo "hash:\n";
var_dump($buf);
$key mb_substr($buf,0,32);
$iv mb_substr($buf,32,16);
}
?>


Lo escribí en PHP ya que es mas fácil darle seguimiento a las funciones hash, solo que no estoy 100% seguro de como manejar las copia de los bytes del hash resultante al key y al IV respectivamente.

Saludos
#13
Muy buena dia, estoy con una pequeña duda ya que estoy tratando de automatizar un proceso de crackeo por fuerza bruta de una key de 256 bits (Se que es improbable, sin embargo la clave esta ahi del 0 al 2^256)  :rolleyes: :rolleyes: :rolleyes:

La función original recibe 2 parametros un un KeyCifrada, y el candidato a Key como segundo parametro:

Decrypt(KeyCifrada,KeyCandidato);

Dicha función realiza un llamado internamente a AES256CBCDecrypt


   AES256CBCDecrypt dec(Key.data(), IV.data(), true);
   nLen = dec.Decrypt(KeyCifrada.data(), KeyCifrada.size(), KeyCandidato);
   if(nLen == 0)
       return false;


y si nLen es igual a 0 entonces retorna false indicando que Key Candidato no es un Key valido.

Mi duda es la siguiente como determina internamente AES256CBCDecrypt  que la KeyCandidato es valida.

Saludos



Edit
Platicando con Kub0x me corrigio el KeyCandidato no es parámetro de entrada si no de salida

Si vemos el link
https://fabcoin.pro/aes_8cpp_source.html#l00176

en la linea 112 hay se muestra que las comprobaciones las hace directamente sobre el texto descifrado y si alguna de ellas no pasa simplemente regresa 0.

Me comenta kub0x que  existen varios valores Key y IV de entrada que podrian dar una salida valida, siendo esto un falso positivo, sin embargo me gustaría investigar cuantas veces pasa eso en realidad.

Saludos




Edit 2
Tal como menciono Kub0x, el proceso arroja muchos falsos positivos.

Programe un programa multihilo para crackear un key

albertobsd $ g++ -o crack_wallet_mt crack_wallet_mt.c -Wint-to-pointer-cast  -pthread
albertobsd $ ./crack_wallet_mt
OK
Thread 3, count: 142
key_material: 6120fbf417fcf689ce5ef35f8094d2e4ff584f2652fff824c94c23dae07633e7
iv_material: 226fe385941a98f5fa0274f2917793c7
decipher_key: 01f970cde83114aef95f5bda80866249053b3067a25cd551fa87d57e9a1406be72496a13439c363ee317b478966891
OK
Thread 2, count: 296
key_material: 4c167299eabda7932ce63d2ca44045a45f00316a45ca72a4acfca3bdd73fd2a5
iv_material: fc238b78db6d6d3c3ebc4cdb4075ccef
OK
Thread 1, count: 443
decipher_key: 0053614707620edd364dfd688249bcf316ba2973df40fa6fa70df7bb532bbc483de465c8e9336c2ef66dc51a7633d4
key_material: 609615afd2c0714b603d077cae58b8561e1fae8445a87cf0c1e8847be0c9acca
iv_material: 36b905f01e1b898b3cd3efa298db88da
decipher_key: a7333cf2484dbc21158b25600a131d707bbb38d4f6dd2fff92e6c2dae3d8c053499ffa19532a99b3c48a59d2574ecc
OK
Thread 0, count: 773
key_material: 93cb1954410e9676fbbf3cd6b17ccfaae4d8e874b6f577e32b9bbbd1c37ea0c3
iv_material: 5fd321427cd14a9ae2c9a2f95f14d629
decipher_key: fdfebebeb779e4df9aa76746f02cd000d93c6e69d7b4fad30214369a2dab84295716a30dc585efcd6a22a16235


Con solo 4 Hilos y solo probando 1554 hashes random me dio 4 resultados que la función AES256CBCDecrypt considera válidos, pense que serian mucho menos el ratio de falsos positivos, pero asi no me da tiempo de probarlos manualmente, tendrás que optimizar ese proceso también.


#14
Muy buenos días compañeros.

Por algun momento pense en colar el titulo de "ayuda mi programa se cierra sin motivo", pero no es demasiado genérico y solo un novato lo haría

Quiero explorar los diversos motivos por los que un programa en C se cierra. De momento vienen a mi mente los siguientes motivos:

  • llamaa explicita a exit o variantes
  • bufferoverflow y variantes de segment fault
  • NULL pointer... (parecido al anterior)
  • No poder asignar mas memoria
  • No poder crear mas threads

    Algunos son salidas explícitamente programadas y otras son por bugs.

    Tengo un proyecto en C, es un servidor WEB multihilo:

    https://github.com/albertobsd/chttpserv

    De momento funciona bien cuando hago peticiones mediante  curl incluso soporta un ciclo sin fin de peticiones:

    Código (bash) [Seleccionar]
    while true; do curl -i http://localhost:3002/ ; done

    Sin embargo cuando le hago las peticiones desde cualquier otro navegador que procese todos los archivos y CIERRO el navegador a media carga el programa simplemente se sale sin mensaje de error.

    OJO que solo es cuando cierro a media carga, si espero a que termine de cargar la pagina por completo esto no sucede.

    Consideraciones:
  • Estoy totalmente seguro de que la mayoría de las funciones que pueden dar error están correctamente procesadas y muestran el error correspondiente:


    s = pthread_create(&tid,&attr,thread_process,(void *)tothread);
    if(s != 0) {
    perror("pthread_create");
    }


  • Todas las funciones de lectura y escritura en el socket se valida si leyeron o escribieron los datos y no devolvio error:

    while(sended >= 0  && readed >= 0 && !feof(fd)  ) {
    readed = fread(buffer,1,128,fd);
    if(readed > 0)
    sended = send(hsc->client_fd,buffer,readed,0);
    }
    if(sended ==  -1) {
    perror("send");
    }
    if(readed == -1) {
    perror("fread");
    }


  • También estoy seguro que no es un problema de memoria ya que tengo una libreria propia con la que me he asegurado tras varias pruebas de que todos los apuntadores asignados con malloc/calloc son liberados y no se vuelven a utilizar, ademas de indicarme la cantidad de memoria dinamica actualmente utilizada.
  • De igual manera todos los sockets son cerrados mediante:


    shutdown(hsc->client_fd,SHUT_RDWR);
    close(hsc->client_fd);


    Se que el problema tiene que ver con Sockets ya que solo cuando cierro el navegador a media carga el programa termina.

    Me he quedado un poco estancado, ya que siento que no avanzo si no soluciono ese error.

    No les pido que depuren mi codigo, ya que no esta 100% documentado.

    Pregunto: ¿Alguien a tenido el mismo problema?, ¿Que otros motivos hacen que el programa se cierre y no caiga error en ninguna función?

    Saludos
#16
Seguramente muchos de ustedes han visto esos códigos javascript Semiofucados ejemplo:

Código (javascript) [Seleccionar]
!function(a){function k(k){for(var n,a,f=k[0],d=k[1],u=k[2],l=0,b=[];l<f.length;l++)o[a=f[l]]&&b.push(o[a][0])
....


Y asi le sigue por unos cuantos Kilobytes de codigo minificado.

Entonces esa es la pregunta, cual es la mejor forma de depurar que es lo que esta haciendo, pregunto por que javascript es bastante permisivo con la sintaxis.

Obvio primer paso:
-- Utilizar alguna de esas paginas para que el código se vea indentado y tabulado

Saludos!
#17
Modo Paranoico ON

Post Original: https://albertobsd.dev/blog/es/2020/01/no-guardar-email-en-texto-plano/

Déjame repetirte el titulo

No guardar el email en texto plano en la base de datos, No se necesita, no se requiere, es mas seguro.

Según esta publicación (Lectura recomendada)

https://medium.com/@alex.birsan/the-bug-that-exposed-your-paypal-password-539fc2896da9

Bug bounty de 15mil $ USD

Si nos ponemos paranoicos, no deberías de conocer el email del usuario, No se necesita, no se requiere.

¿Que dato valido entonces? Un hash del mismo email protegido con alguna key, Importante: Que no sea reversible es decir que teniendo el hash no exista forma de volver al email y/o password originales.

Los siguientes códigos requieren de un archivo key_db.dat el cual se puede generar con dd leyendo de /dev/random o con el método que mas les guste.

Código (php) [Seleccionar]

/*
metodo con hash_pbkdf2
*/
$halgo = "sha256";
$iterations = 2000000;
$email = "user@example.com";
$password = "P4ssw0rd";
$salt = hash_file($halgo,"key_db.dat",true);
$salida_email = hash_pbkdf2($halgo,$email,$salt,$iterations,0);
$salida_password = hash_pbkdf2($halgo,$password,$salt,$iterations,0);
echo "hash email: $salida_email\n";
echo "hash password: $salida_password\n";


/*
metodo Iterativo con hash_hmac ()
*/
$i = 0;
$data_email = substr($email,0);
$data_password = substr($password,0);
do {
$data_email = hash_hmac($halgo,$data_email,$salt,true);
$data_password = hash_hmac($halgo,$data_password,$salt,true);
}while($i++ < ($iterations - 1));
$data_email = hash_hmac($halgo,$data_email,$salt,false);
$data_password = hash_hmac($halgo,$data_password,$salt,false);
echo "hash email: $data_email\n";
echo "hash password: $data_password\n";

/*
metodo Iterativo solo con hash  (data y key concatenadas)
*/
$i = 0;
$data_email = substr($email,0);
$data_password = substr($password,0);
do {
$data_email = hash($halgo,$data_email.$salt,true);
$data_password = hash($halgo,$data_password.$salt,true);
}while($i++ < ($iterations - 1));
$data_email = hash($halgo,$data_email.$salt,false);
$data_password = hash($halgo,$data_password.$salt,false);
echo "hash email: $data_email\n";
echo "hash password: $data_password\n";



Nota que coloque Iteraciones igual a 2 Millones ya que no sabemos en un futuro que tan feasible sea realizar algun forcebrute a los hashes.

NO SE NECESITA GUARDAR EL EMAIL EN PLANO
- El usuario no se acuerda de su clave? Pides el email y aplicas el mismo algoritmo, se busca en la base de datos y si coincide con alguno de los hash envias el email, basándose en el email que te enviaron obviamente validando que sea email valido filter_var($email, FILTER_VALIDATE_EMAIL)

NO SE NECESITA, ok quieres enviarles noticias o mensajes cada X tiempo
- Se puede utilizar criptografía simétrica para guardar el email pero si te hackean la base de datos y el código fuente, lo van a poder obtener ellos mismos

déjame Repetírtelo una vez mas NO SE NECESITA GUARDAR EL EMAIL EN TEXTO PLANO

Incluso solo se necesita recibir el email en texto plano en 2 ocasiones, solo cuando se registra (Para validar que sea valido) y cuando quiere recuperar su password.

Para el login diario podrías recibir  solo un hash del mismo

var email = CryptoJS.SHA512($("#email").val()).toString().substring(1, 127);

Se le quitan 2 nibbles de los extremos al hash antes de ser enviado, por si se llega a interceptar en transito por algun exploit, no se pueda determinar al 100% cual es el email inicial

Se podría aplicar lo mismo al password (Muy recomendable asi tu nunca vez el password original del usuario)

Saludos!




#18
Tengo configurado un proxy Socks5 implementado mediante ssh tunneling a un servidor dedicado, estoy 100 % seguro que soy el único que lo utiliza como proxy por que yo administro el servidor mencionado.

El punto aquí, es como puede detectar una pagina que visito si estoy usando un proxy Socks5?

He hecho pruebas y el navegador con y sin proxy manda exactamente mismas headers ademas también se que los scripts no puede acceder a la IP Publica Real si estoy con el proxy habilitado.

Pregunto estoy por que servicios como Netflix y otras paginas me detectan que estoy utilizando este tipo de técnicas.

Saludos!
#19
Alguna buena recomendación de un Libro y/o tutorial de Expresiones Regulares a fondo.

A ver, puedo entrar a google, buscar y empezar con lo primero que encuentre, eso lo se, sin embargo busco alguna recomendación personal que alguno de ustedes ya curso y/o a leído sobre el tema.

Ya sea en Ingles o en español no tengo problema con el lenguaje.

Tengo tiempo tiempo programando y he usado una que otra Regex anteriormente (Solo he usado las entiendo) y muchas veces las pruebo manualmente contra posibles inputs indeseados. Sin embargo nunca me he dado el tiempo suficiente para profundizarlas.

Saludos!
#20
He estado algo estancado con la siguiente duda.

El operador ^ es un XOR, un código de javascript lo aplica asi.

Código (javascript) [Seleccionar]
for (var i = 0; i < ckey.sigBytes/4; i += 1) {
ckey.words[i] = ckey.words[i] ^ csig.words[i]
}


Donde words son números enteros signed de 32 bits, sigBytes son vale 32,  La api de javascript lo maneja de esa forma, en PHP yo tengo el binstring de 32 bytes (raw de un hash sha256) ¿si yo realizo el XOR a los bytes individuales uno a uno llego al mismo resultado?

Ejemplo.
Código (php) [Seleccionar]
while($i < 32) {
$ckey[$i] = $ckey[$i] ^ $csig[$i];
$i++;
}


Creo que la pregunta es algo boba, pero a esta altura del dia ya no tengo cabeza para  responderme yo mismo.

Saludos!



Solucionado

Si es lo mismo, todo depende que las variables evaluadas sean del mismo tamaño. Como comenta MinusFour.

Saludos!
#21
Desarrollo Web / Depuración (In)Segura
3 Enero 2020, 06:56 AM
Los que ya tengan algo de tiempo programando en PHP, sabrán que la mayoría de los servidores tipo hosting están configurados para que el Server no tire los mensajes de error hacia el navegador. Esto complica un poco el tema a la hora de realizar un poco de depuración en un sitio en producción. Lo ideal seria tener un equipo para depurar el código fuera del entorno de producción, depurar y volver a subir el codigo ya corregido, esto es el deber ser cuando trabajas sobre el sitio de alguien mas.

Sin embargo en mi caso y para mi pagina personal, me da mucha flojera estar haciendo las cosas como debería de ser, lo cual he implementado un forma de depuración un tanto protegida. NOTA sigue siendo inseguro, pero dado que lo password basados en el tiempo de UNIX que duran 30 segundos son algo difíciles de adivinar y poco probable que alcances a forcebrutear las 999999 posibilidades en los 30 segundos que dura el password, confio el que el metodo es mas o menos seguro para lo que necesito.

La idea es básicamente la siguiente, incluir un archivo en el index que busque si existe la variable debug y si existe válida si el valor es igual generado mediante la función TOTP (Función que publique en este mismo subforo ) Si estas condiciones se cumplen habilita que se muestren los errores que arroje el PHP

Código (php) [Seleccionar]
<?php
if(isset($_GET["debug"]) {
$valor $_GET["debug"];
$key file_get_contents("s3cr3ct_dir/"."key.dat");
if(strncmp($valor,totp($key),6) == 0) {
ini_set('display_errors'1);
ini_set('display_startup_errors'1);
error_reporting(E_ALL);
header("debug: enabled");
}
else {
header("debug: invalid totp");
}
}
?>


Consideraciones

  • No, no tengo un directorio "s3cr3ct_dir/"
  • El archivo key.dat se genero mas o menos asi dd if=/dev/urandom of=key.dat bs=1K count=1
  • Se tiene que configurar alguna aplicación authenticator (Obvio)
  • Se puede intentar forcebrutear el valor actual del Totp (999999) posibilidades  en 30 segundos
  • Se puede intentar forcebrutear el valor actual del KEY 2^8192 posibilidades en Toda una eternidad
  • Actualmente están los headers activos así que pueden intentarlo, tengo un /dummy que no hace nada, pero los headers se mostrarían
  • Si se desactivan los headers no hay manera de saber si X sitio implementa una técnica similar
  • Se puede cambiar el nombre de la variable
  • Tiene que existir un error en la pagina para que sirva de algo

🏴

Saludos!
#22
Se me hace interesante esas paginas que ofrecen solo un servicio como el de imagen placeholder

Para las plantillas de diseño HTML esta muy bien:

Ejemplo:

https://placehold.it/70x70



Yo mismo implemente una imagen así pixeles random:

https://albertobsd.dev/random?format=img&w=70&h=70



Ahora estoy implementando el mismo código en otro sitio y me estoy dando de topes por que no esta funcionando :xD :xD :xD

Código (php) [Seleccionar]
<?php
$h 100;
$w 100;
if(isset($_GET["w"]) && intval($_GET["w"]) > 0) {
$w intval($_GET["w"]);
}
if(isset($_GET["h"]) && intval($_GET["h"]) > 0) {
$h intval($_GET["h"]);
}
$im imagecreate($w$h);
$gray imagecolorallocate ($im 50 50 50 );
imagefill$im ,$w $h $gray );
header("Cache-Control: no-cache, no-store, must-revalidate");
header("Pragma: no-cache");
header("Expires: 0");
header("Content-type: image/png");
imagepng($im);
imagedestroy($im);
?>


El codigo anterior asi como el siguiente no me arroja imagen alguna, en teoría me debería de arrojar la imagen con fondo gris, peor no hace nada, ya intenten depurando con headers:

Código (php) [Seleccionar]
<?php
$h 100;
$w 100;
if(isset($_GET["w"]) && intval($_GET["w"]) > 0) {
$w intval($_GET["w"]);
}
if(isset($_GET["h"]) && intval($_GET["h"]) > 0) {
$h intval($_GET["h"]);
}
$im imagecreate($w$h);
$gray imagecolorallocate ($im 50 50 50 );
$white imagecolorallocate ($im 255 255 255 );
if(imagefill$im ,$w $h $gray )) {
header("Imagefill: OK");
}
header("Cache-Control: no-cache, no-store, must-revalidate");
header("Pragma: no-cache");
header("Expires: 0");
header("Content-type: image/png");
$tfile tempnam("/tmp","FOO");
if(imagepng($im,$tfile,0)) {
header("Imagepng: OK");
}
if(imagedestroy($im)) {
header("Imagedestroy: OK");
}
header("N: $tfile");
header('Content-Length: ' filesize($tfile));
readfile($tfile);
unlink($tfile);
?>


Y sigue sin hacer absolutamente nada, los headers de depuración están todos y el archivo se crea, intente omitiendo el unlink y haciendo file al archivo temporal desde el shell de linux y todo esta bien:

$ file /tmp/FOOxOdebm
/tmp/FOOxOdebm: PNG image data, 750 x 300, 1-bit colormap, non-interlaced


Headers desde el navegador:



Al final el error va a terminar siendo una tontería pero se me hace interesante que no arroje nada.

Saludos!
#23
Tengo implementado un sistema de bloqueos por URL (ya saben tipo /wp/login.php etc...), Usert Agent (Claramente modificados), Session (Previamente detectadas).

Si alguno de la lista se encuentra en el blacklist la IP se bloquea por algunas horas y ando un codigo de error 500.

La pregunta por recomendación aquí: ¿Es el mejor camino a seguir?, es decir ¿Bloquear el acceso y mandar error 500 o 404 es la mejor forma de proceder?

Saludos
#24
Bueno, lo pongo aqui por que no se si corresponde mas a seguridad o PHP, pero su implementación ayuda mucho en el desarrollo WEB. Que algun moderador lo mueva a donde sea mas conveniente.

Estoy implementando el algoritmo para HOTP (HMAC-based One-time Password Algorithm) En su modalidad basada en el tiempo de UNIX

Actualemente tengo lo siguiente:

Código (php) [Seleccionar]

/*
dd if=/dev/urandom of=./key.dat bs=1024 count=1
*/
$key = file_get_contents("./key.dat");
$ct = floor(time()/30);
echo hash_hmac("sha1",$ct,$key)."\n";


El código actualmente genera un hash distinto cada 30 segundos exactos mi duda es como llegar a los 6 u 8 dígitos que muestra la aplicaciones de Authenticator como la de google.

Nota para los que me digan que no utilize sha1, lo utilize por que wikipedia indica que es el default, pero espero que pueda ser configurable para utilizar sha256 y alguno de la misma familia.

https://en.wikipedia.org/wiki/HMAC-based_One-time_Password_algorithm

Saludos.




Solucionado gracias a las observaciones de MinusFour.

La funcion quedo de la siguiente manera:

Código (php) [Seleccionar]
function hotp($key,$c) {
$mask = ['f' => '7','e' => '6','d' => '5','c' => '4','b' => '3','a' => '2','9' => '1','8' => '0'];
$hash_value_str = hash_hmac("sha1",pack("H*",sprintf("%016x",$c)),$key);
$offset = intval($hash_value_str[39],16)*2;
$extract = substr($hash_value_str,$offset,8);
if(isset($mask[$extract[0]])) {
$extract[0] = $mask[$extract[0]];
}
$value = intval($extract,16);
return ($value % 1000000);
}


Y para utilizarlo solo basta llamarla:

Código (php) [Seleccionar]
$ct = floor(time()/30);
$key = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
printf("%06d\n",hotp($key,$ct));


Esto arroja los 6 dígitos que deben de coincidir con la aplicación de Autenticador que tengamos instalada en el móvil.

Para este ejemplo se puede configurar manualmente como se muestra en una las imágenes.

#25
Dudas Generales / Emoji Fingerprint
20 Diciembre 2019, 09:04 AM
Estoy armando una base de datos algo grande con "firmas" de emojis de distintos navegadores, los emojis varían mucho a veces por tamaño y/o cambios del diseño entre modelos de equipos y/o marcas asi como de versión del sistema operativo. En fin, muchas variaciones disponibles: Ejemplo mismo código de emoji distintos fingerprint









La pregunta aquí seria cual es la mejor forma de "identificar el navegador y demas datos" con el menor numero de que "consultas".

Se me ocurre algún tipo de búsqueda binaria categorizando primero el sistema operativo y después el navegador, y tal vez por último el modelo pero solo una idea.

Espero sus comentarios.

Saludos!



TL;DR; Por ciero el tema mas o menos viene del articulo que publique en mi blog  Dibujar emojis en canvas html5
#26
Entrada tambien en mi blog:
Validacion de token de forma Criptografica, evitar ataques CSRF


Bueno esto viene del tema que abrio el usuario MiguelCanellas    
[Aporte]: Sistema Anti ataques CSRF (Espero sugerencias)
.

La forma mas sencilla de genera un token sin incluir nada de criptografia  y que se envie al usuario para posteriormente ser validado es la siguiente:

Código (php) [Seleccionar]
$token = hash("sha256",random_bytes(32));

Esto nos produce una cadena hash sha256 apartir de 1Kilobyte de datos random.

La cosa seria sencilla guardarlo en la $_SESSION en el server y mandarlo al usuario, si lo devuelve comparamos que sean iguales y listo no hay mucho pierde.

Se necesita mas seguridad.... ?

El simple hecho que tengamos una cadena hash sha256 apartir de 1Kilobyte de datos random. hace casi imposible que alguien pueda generar el token por si solo y que coincida con el que generamos nosotros, podriamos incrementar la cantidad de bytes generados por la funcion openssl_random_pseudo_bytes simplemente incrementando su valor.

Ahora si realmente queremos proteger la informacion mediante criptografia tenemos que hacer las cosas bien.

Una implentacion rapida para ejemplificar este proceso es la siguiente:

Código (php) [Seleccionar]
<?php
$cipher 'AES-256-CBC'; //SUIT de cirado utilizada 
$strkey "s3cr3tk3yh4x0r"; //Clave en el servidor, secreta, cambiar esta clave de ejemplo POR FAVOR de preferencia utilizar una clave generada de forma segura con openssl_random_pseudo_bytes o /dev/random
$realkey hash("sha256",$strkey,true); //Hash de la clave en formato Raw
$ivlen openssl_cipher_iv_length($cipher); // Obtenemos el tamaño del Vector Inicializado de acuardo a la Suit de cifrado que estemos utilizando
$iv openssl_random_pseudo_bytes($ivlen); // Obtenemos $ivlen bytes random no nos interesa saber su valor
$token hash("sha256",random_bytes(32)); //Token sin cifrar este valor nuca lo ve el UserAgent
$token_cifrado openssl_encrypt($token,$cipher,$realkey,OPENSSL_RAW_DATA,$iv); 
$salida base64_encode($token_cifrado); //Este valor si lo ve el User Agent
echo "token: ".$token."\n";
echo "token cifrado, salida raw: ".$token_cifrado ."\n";
echo "token cifrado, salida base64: ".$salida."\n";
$entrada base64_decode($salida);
$token_decifrado openssl_decrypt($entrada,$cipher,$realkey,OPENSSL_RAW_DATA,$iv);
echo "token decifrado: ".$token_decifrado ."\n";
if($token_decifrado == $token) {
echo "token correcto\n";
}
else {
echo "token Incorrecto\n";
}
?>


Si vemos el codigo anterior el "token" que enviaremos al usuario es la salida en base64 del token previamente cifrado.

Acontinuacion una posible salida de las casi infinitas salidas....

token: 5ab8aac170554a2683e0cc0534a34e80d0f16031a13faa3c3a5ee44902b2c6a1
token cifrado, salida raw: CU?!,F8C4d 1su
       SN{|큮vDjUa=qQKKKȀE#(@/I
token cifrado, salida base64: AUO6plUB9j8h+IvsyixGOAfZQzRkCzG84XN1vN7X2Aq2CVNOont87YGudsJEq2q1VWE9vZhxqJWfUUviv0tL9ciA+kWTI74oGEAvl4sSSak=
token decifrado: 5ab8aac170554a2683e0cc0534a34e80d0f16031a13faa3c3a5ee44902b2c6a1
token correcto


La idea en este caso es enviar la informacion cifrada al usurio y cuando este la envie devuelta se descifra y se compara con la almacenada previamente en la $_SESSION del usuario.
Cosas que se pueden mejorar el valor de nuestra Key inicial podria ser un archivo random en nuestro servidor generado previamente, podriamos tener una llave distinta por usuario, etc etc etc...
#27
Funte: Como crear un formulario de comentarios para tu web

Pues nada lo primero es tener el Formulario en HTML.
Posterior mente el javascript para validar el formulario antes de enviarlo
El script en el Backend para volver a validar los datos.
El metodo de almacenamiento del comentario (Base de datos)
Un sistema para evitar que saturen de comentarios basura
Y al final pero mas importante EVITAR SER HACKEADO (xss, sql, file inclusion etc etc etc etc etc)

El codigo en HTML para el formulario utilizando Boostrap:
Código (html4strict) [Seleccionar]

<h4>Deja un comentario</h4>
<p></small>Tu dirección de correo electrónico no será publicada. <b>Los campos obligatorios están marcados con *</b></small></p>
<div class="form-group">
<label for="exampleInputUsername">Nombre *</label>
<input type="text" class="form-control" id="exampleInputUsername" aria-describedby="usernameHelp">
<small id="usernameHelp" class="form-text text-muted">Nombre para mostrar, este campo si va a ser mostrado</small>
</div>
<div class="form-group">
<label for="exampleInputEmail">Correo Electronico *</label>
<input type="email" class="form-control" id="exampleInputEmail1" aria-describedby="emailHelp">
<small id="emailHelp" class="form-text text-muted">Tu direccion de correo electronico no sera publicada</small>
</div>
<div class="form-group">
<label for="exampleInputWEB">WEB *</label>
<input type="text" class="form-control" id="exampleInputWEB" aria-describedby="webHelp">
<small id="webHelp" class="form-text text-muted">Direccion WEB Segura valida ejemplo: https://www.example.com/</small>
</div>
<div class="form-group">
<label for="exampleTextAreaComentario">Comentario *</label>
<textarea class="form-control" id="exampleTextAreaComentario" rows="5" aria-describedby="comentarioHelp"></textarea>
<small id="comentarioHelp" class="form-text text-muted">Todos los comentarios seran moderados antes de ser publicados</small>
</div>
<div class="form-group form-check">
<input type="checkbox" class="form-check-input" id="exampleCheckboxSubscribe">
<label class="form-check-label" for="exampleCheckboxSubscribe">Recibir notificaciones de Respuestas a tus comentarios</label>
</div>
<button type="button" class="btn btn-primary">Publicar Comentario</button>
<button type="button" class="btn btn-secondary">Vista Previa</button>
<div id="comentario_vista_previa">
</div>




Resultado:


#28
Fuente Utilizar reCAPTCHA v3 para evitar intentos de fuerza bruta

En el Post que acabo de publicar básicamente se muestra el código en javascript y en PHP para implementar el reCAPTCHA v3 en un Formulario para evitar ataques de fuerza bruta.

Codigo en PHP:

Código (php) [Seleccionar]

<?php
try {
  
//Validar datos POST or GET aqui.
  
$post_data http_build_query(
    array(
        
'secret' => "SECRET KEY HERE THIS VALUE MUST BE PRIVATE...",
        
'response' => $_POST['reCAPTCHA_Token'],//Token devuelto por Google al Front End y enviado a este formulario
        
'remoteip' => $_SERVER['REMOTE_ADDR'//Direccion IP publica del cliente que envia el formulario
    
)
  );
  
$opts = array('http' =>
    array(
    
'method'  => 'POST',
    
'header'  => 'Content-type: application/x-www-form-urlencoded',
    
'content' => $post_data
    
)
  );
  
$context  stream_context_create($opts);
  
$response file_get_contents('https://www.google.com/recaptcha/api/siteverify'false$context);
  
$result json_decode($response);
  if(
$result->action != $_POST["action"]) {
    throw new 
Exception("Google recaptcha action missmatch");
  }
  if(
$result->score 0.5) {
    throw new 
Exception("Google recaptcha score too low");
  }
  
//Devuelta a las validaciones actuales de seguridad para los datos recibidos 
}catch(Exception $e) {
  
//catch exception here
}
?>


saludos!
#29
Hola que tal espero y me puedan ayudar, tengo un error de lo mas tonto. Sin embargo no se por que el jquery no esta enviando el data mediante Ajax.

JS
Código (javascript) [Seleccionar]

function local_search() {
$.ajax({
async: true,
type: "GET",
accepts: "application/json",
url: "/api/search",
data: { s: $("#input_str").value },
success: function (result) {
alert(result.ok);
}
});
}


HTML:
Código (html4strict) [Seleccionar]

<div>
<input id="input_str" type="text">
<button onclick="local_search();">Buscar</button>
</div>


Puedo ver que si hace la peticion al servidor, pero no envia nunca la data

RAW Request

Host: localhost
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:63.0) Gecko/20100101 Firefox/63.0
Accept: undefined
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Referer: http://localhost/
X-Requested-With: XMLHttpRequest
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache





Solución

Codigo Incorrecto
data: { s: $("#input_str").value },

Codigo Correcto

[code] data: { s: $("#input_str").val() },[/code]
#30
Noticias / Hackean Quora?
4 Diciembre 2018, 03:05 AM
Dear ......

We are writing to let you know that we recently discovered that some user data was compromised as a result of unauthorized access to our systems by a malicious third party. We are very sorry for any concern or inconvenience this may cause. We are working rapidly to investigate the situation further and take the appropriate steps to prevent such incidents in the future.

What Happened

On Friday we discovered that some user data was compromised by a third party who gained unauthorized access to our systems. We're still investigating the precise causes and in addition to the work being conducted by our internal security teams, we have retained a leading digital forensics and security firm to assist us. We have also notified law enforcement officials.

While the investigation is still ongoing, we have already taken steps to contain the incident, and our efforts to protect our users and prevent this type of incident from happening in the future are our top priority as a company.

What information was involved

The following information of yours may have been compromised:

    Account and user information, e.g. name, email, IP, user ID, encrypted password, user account settings, personalization data

    Public actions and content including drafts, e.g. questions, answers, comments, blog posts, upvotes

    Data imported from linked networks when authorized by you, e.g. contacts, demographic information, interests, access tokens (now invalidated)

Questions and answers that were written anonymously are not affected by this breach as we do not store the identities of people who post anonymous content.

What we are doing

While our investigation continues, we're taking additional steps to improve our security:

    We're in the process of notifying users whose data has been compromised.
    Out of an abundance of caution, we are logging out all Quora users who may have been affected, and, if they use a password as their authentication method, we are invalidating their passwords.
    We believe we've identified the root cause and taken steps to address the issue, although our investigation is ongoing and we'll continue to make security improvements.

We will continue to work both internally and with our outside experts to gain a full understanding of what happened and take any further action as needed.

What you can do

We've included more detailed information about more specific questions you may have in our help center, which you can find here.

While the passwords were encrypted (hashed with a salt that varies for each user), it is generally a best practice not to reuse the same password across multiple services, and we recommend that people change their passwords if they are doing so.

Conclusion

It is our responsibility to make sure things like this don't happen, and we failed to meet that responsibility. We recognize that in order to maintain user trust, we need to work very hard to make sure this does not happen again. There's little hope of sharing and growing the world's knowledge if those doing so cannot feel safe and secure, and cannot trust that their information will remain private. We are continuing to work very hard to remedy the situation, and we hope over time to prove that we are worthy of your trust.

The Quora Team
#31
Muy buen dia.

Estoy trabajando con un servidor http de lo mas básico posible.

Tengo un error al momento de enviar el contenido. El navegador a veces recibe los archivos incompletos y no logro ubicar el error.



El navegador indica que solo recibe 768KB para el penultimo archivo "/test.mp3"

La salida del programa indica lo siguiente para ese archivo.



Leido indica la cantidad de bytes que a leido desde el archivo:


fseek(contenido,offset,SEEK_SET);
leido = fread(buffer,1,size,contenido);
printf("Leido %i %s\n",leido,path);
if(leido != size) {
fprintf(stderr,"fread() read %i vs request %i\n",leido,size);
exit(0);
}
fclose(contenido);


leido toma la cantidad que devuelve fread, si leido y size son distintos el programa termina inmediatamente.


Posteriormente mando ese buffer leido al comando send.


int send_all(SOCKET descriptor, const void *buffer, size_t length, int flags) {
printf("send_all\n");
   ssize_t n;
   const char *p = buffer;
   while (length > 0)
   {
       n = send(descriptor, p, length, flags);
printf("send: %i bytes\n",n);
       if (n <= 0)
           return -1;
       p += n;
       length -= n;
   }
   return 0;
}


send all indica mediante la variable "n" la cantidad de datos enviados por send.

Asi mismo en los headers recibe correctamente el mismo numero indicado por el programa:



Asi que dado que la cantidad de items leidos por fread es la misma que la cantidad de bytes enviados por send, no entiendo por que el navegador no recibe todo el archivo, ya que al momento de tratar de reproducirlo esta incompleto.

Saludos




Al final quedo solucionado modificando la funcion send all. Por alguna razon dice que a enviado todos lo 2 MB pero el navegador  solo recibio los 700 KB. Modique la funcion para que envie de 64 bytes por vez y ahora envio el documento completo

int send_all(SOCKET descriptor, const void *buffer, int length, int flags) {
int n,s;
const char *p = buffer;
while (length > 0) {
s = ( length > 64 ) ? 64: length;
n = send(descriptor, p, s, flags);
if (n <= 0)
return -1;
p += n;
length -= n;
}
return 0;
}




Y el programa marca exactamente la misma cantidad.


Saludos!
#32
No es lo mas eficiente, hay muchas cosas se podrian mejorar, en especifico la forma en la que se organizan  el arreglo de elementos actuales en la Fila,  sin embargo funciono para el proposito.

Yo se que la mayoría de estas estructuras ya están implementadas. Pero no se puede decir que eres programador si no sabes implementarlas por tu cuenta.




/*
El tipo de dato se puede cambiar dependiendo de la implementación que se le quiera dar, también se tendrían que cambiar los tipos de datos devueltos por las funciones
En este caso yo quería un arreglo de apuntadores char* por lo cual el contenedor es char**
*/


typedef struct str_queue {
char **queue;
int len;
int max;
}Queue;

Queue *create_queue() {
Queue *r = malloc(sizeof(struct str_queue));
r->len = 0;
r->max = 2;
r->queue = malloc(sizeof(char*)*r->max);
return r;
}

void free_queue(Queue *q) {
if(q) {
if(q->queue)
free(q->queue);
free(q);
}
}

void en_queue(Queue *q, char *ptr) {
if((q->len+1) == q->max) {
q->max *= 2;
q->queue = realloc(q->queue,q->max*sizeof(char*));
}
if(q->queue != NULL) {
q->queue[q->len] = ptr;
q->len++;
}
}

char * de_queue(Queue *q) {
char *r = NULL;
int i = 0;
if(q->len >= 1) {
r = q->queue[0];
q->len--;
while(i < q->len) {
q->queue[i] = q->queue[i+1];
i++;
}
q->queue[i] = NULL;
}
return r;
}


Yo en su momento lo utilize para un post, donde realizaba una versión iterativa y necesitaba almacenar en una Cola el listado de los directorios que aun faltaba por recorrer:

problema de memoria con readdir (Solucionado)

Ejemplo de uso:


int main() {
char *cadenas[10] = { "Cadena_0","Cadena_1","Cadena_2","Cadena_3","Cadena_4","Cadena_5","Cadena_6","Cadena_7","Cadena_8","Cadena_9"};
char *actual;
int index1,index2,i =0;
srand(time(NULL));
Queue *q = create_queue();
while(i < 10) {
index1 = rand() % 10;
index2 = rand() % 10;
printf("Agregando a la fila: %s\n",cadenas[index1]);
en_queue(q,cadenas[index1]);
printf("Agregando a la fila: %s\n",cadenas[index2]);
en_queue(q,cadenas[index2]);
printf("Saliendo de la fila %s\n",de_queue(q));
i++;
}
free_queue(q);
}


Como es randon la salida es variada, pero podemos observar el funcionamiento:




Agregando a la fila: Cadena_5
Agregando a la fila: Cadena_5
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_2
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_5
Agregando a la fila: Cadena_7
Saliendo de la fila Cadena_8
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_7
Saliendo de la fila Cadena_2
Agregando a la fila: Cadena_9
Agregando a la fila: Cadena_2
Saliendo de la fila Cadena_5
Agregando a la fila: Cadena_1
Agregando a la fila: Cadena_3
Saliendo de la fila Cadena_7
Agregando a la fila: Cadena_8
Agregando a la fila: Cadena_5
Saliendo de la fila Cadena_8
Agregando a la fila: Cadena_0
Agregando a la fila: Cadena_3
Saliendo de la fila Cadena_7
Agregando a la fila: Cadena_4
Agregando a la fila: Cadena_0
Saliendo de la fila Cadena_9
Agregando a la fila: Cadena_7
Agregando a la fila: Cadena_1
Saliendo de la fila Cadena_2





Funcion actualizada de de_queue


char * de_queue(Queue *q) {
char *r = NULL;
int i = 0;
if(q->len >= 1) {
r = q->queue[0];
q->len--;
while(i < q->len) {
q->queue[i] = q->queue[i+1];
i++;
}
q->queue[i] = NULL;
}
return r;
}

#33
Muy buen dia.

Problema: La memoria utilizada por el programa aumenta y no disminuye

Solución: No es un problema, es la memoria que se genera por el paradigma de la recursividad, esto es: que al llamar a la misma función de forma recursiva, el Stack Frame de la memoria que utiliza cada una de las llamadas a la función se acumule.

Intente aplicar una solucion de forma Iterativa, guardando el Path de los directorios que faltan por leer en una Queue, pero utiliza mas memoria  que la solucion recursiva.

readdir devuelve un apuntador de la estructura (struct dirent)
Mas info: https://linux.die.net/man/3/readdir

El cual creo que es el causante de este POST.

Versión Corta

¿Quien controla el Apuntador entregado por readdir?

Es memoria estatica y no se debe de liberar

directorio_archivo_temporal = readdir(directorio)

Al momento de tratar de liberar dicho apuntador, el programa se cuelga...


while(directorio_archivo_temporal = readdir(directorio) ) {
//etc..
free(directorio_archivo_temporal);
}


El problema radica en que la memoria del programa solo aumenta y no disminuye.

Codigo de la version corta funcionando

#include<sys/stat.h>
#include<sys/types.h>
#include<dirent.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int is_regular_file(const char *path);

int procesar_directorio(char *path);

int main(int argc,char **argv) {
switch(argc){
case 2: //Se espera directorio
procesar_directorio(argv[1]);
break;
default:
printf("Numero de argumentos no esperado\n");
break;
}
getchar();

}

int is_regular_file(const char *path) {
struct stat path_stat;
stat(path, &path_stat);
return S_ISREG(path_stat.st_mode);
}

int procesar_directorio(char *path) {
DIR *directorio;
struct dirent *directorio_archivo_temporal;
char *path_copy;
int len_path;
char *path_temporal;
int len_path_temporal;
directorio = opendir(path);
if(directorio != NULL) {
len_path = strlen(path);
path_copy = malloc(len_path+2);
memcpy(path_copy,path,len_path);
if(path_copy[len_path - 1] == '\\' ){
path_copy[len_path] = '\0';
}
else {
path_copy[len_path] = '\\';
path_copy[len_path+1] = '\0';
len_path++;
}
while(directorio_archivo_temporal = readdir(directorio) ) {
len_path_temporal = strlen(directorio_archivo_temporal->d_name);
path_temporal = malloc(len_path+len_path_temporal+1);
path_temporal[len_path+len_path_temporal] = '\0';
sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
if(is_regular_file(path_temporal)) {
printf("%s\n",path_temporal);
}
else { //Directorio?
if( len_path_temporal > 2 ) { //not .. or .
procesar_directorio(path_temporal); //recursivamente
}
}
free(path_temporal);
}
free(path_copy);
closedir(directorio);
}
}










Versión extensa

Aquí esta toda la Letanía

Estoy realizando un programa que lea de forma Recursiva un directorio dado y liste los archivos en pantalla. Nada del otro mundo. Asi mismo estoy haciendo que el formato de salida sea el formato tipo UNIX /bla/bla/bla en lugar del formato de windows C:\lalala\lalalala.txt

Esto con el objetivo de virtualizar el path de subdirectorios específicos para otro programa pero eso ya es harina de otro costal.

El problema es que cuando listo Cualquier carpeta con muchos subdirectorios como la unidad C:\  el programa en empieza usando lo clasico unos 400 KB y termina utilizando 800 KB o mas dependiendo de la carpeta que este listada.

El dia Ayer publique un post parecido:
Problema de memoria en miniservidor usando Winsock (Solucionado)

En el cual se estaba cerrando el socket de forma incorrecta.

En este caso creo que es problema del apuntador devuelto por readdir.

Código del programa funcionando:


#include<sys/stat.h>
#include<sys/types.h>
#include<dirent.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int fsize(const char *filename);
int is_regular_file(const char *path);

int procesar_directorio(char *path,char *virtual_path);

int main(int argc,char **argv) {
switch(argc){
case 2: //Se espera directorio
procesar_directorio(argv[1],"/");
break;
case 3: //Se espera archivo + nombre de directorio de destino.
break;
default:
printf("Numero de argumentos no esperado\n");
break;
}
getchar();

}

int is_regular_file(const char *path) {
struct stat path_stat;
stat(path, &path_stat);
return S_ISREG(path_stat.st_mode);
}

int fsize(const char *filename) {
   struct stat st;
   if (stat(filename, &st) == 0)
       return st.st_size;
   return -1;
}

int procesar_directorio(char *path,char *virtual_path) {
DIR *directorio;
struct dirent *directorio_archivo_temporal,*result;

char *path_copy;
char *virtual_path_copy;
int len_path,len_virtual_path;

char *path_temporal;
char *virtual_path_temporal;
int len_path_temporal;
int len_virtual_path_temporal;


directorio = opendir(path);
if(directorio != NULL) {

len_path = strlen(path);
len_virtual_path = strlen(virtual_path);

virtual_path_copy = malloc(len_virtual_path+2);
path_copy = malloc(len_path+2);
memcpy(path_copy,path,len_path);
memcpy(virtual_path_copy,virtual_path,len_virtual_path);

if(path_copy[len_path - 1] == '\\' ){
path_copy[len_path] = '\0';
}
else {
path_copy[len_path] = '\\';
path_copy[len_path+1] = '\0';
len_path++;
}
if(virtual_path_copy[len_virtual_path - 1] == '/' ){
virtual_path_copy[len_virtual_path] = '\0';
}
else {
virtual_path_copy[len_virtual_path] = '/';
virtual_path_copy[len_virtual_path+1] = '\0';
len_virtual_path++;
}
/*
directorio_archivo_temporal = calloc(1,sizeof(struct dirent));
result == NULL;
*/
//while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){
while(directorio_archivo_temporal = readdir(directorio) ) {

len_path_temporal = strlen(directorio_archivo_temporal->d_name);
//printf("readdir point to %p\n",directorio_archivo_temporal);
//printf("Len %i : %s\n",len_path_temporal,directorio_archivo_temporal->d_name);

path_temporal = malloc(len_path+len_path_temporal+1);
virtual_path_temporal = malloc(len_virtual_path + len_path_temporal+1);

path_temporal[len_path+len_path_temporal] = '\0';
virtual_path_temporal[len_virtual_path+len_path_temporal] = '\0';

sprintf(path_temporal,"%s%s",path_copy,directorio_archivo_temporal->d_name);
sprintf(virtual_path_temporal,"%s%s",virtual_path_copy,directorio_archivo_temporal->d_name);

if(is_regular_file(path_temporal)) {
//printf("Archivo :\"%s\"\n",path_temporal);
printf("%s\n",virtual_path_temporal);
}
else { //Directorio?
if( len_path_temporal > 2 ) { //not .. or .
procesar_directorio(path_temporal,virtual_path_temporal); //recursivamente
}
}
free(path_temporal);
free(virtual_path_temporal);
}
//free(directorio_archivo_temporal);



free(path_copy);
free(virtual_path_copy);
closedir(directorio);
}
else {
printf("El directorio \"%s\" no es un directorio valido\n",path);
}
}


Funciona bien, recibe parametros de entrada, ejemplo

Ejemplo


C:\>generar_contenido.exe contenido
/index.html


Le agregue un getchar al final del archivo para poder ver con cuanta memoria termina el programa. Para carpetas sin tanto subdirecorio no hay problema, el detalle es cuando se trata de todo un disco...

Imagen:


Ya he validado que todos los apuntadores que yo genero de forma dinámica son liberados en su totalidad, esto mediante re implementaciones de malloc,calloc,realloc y free como describo en el siguiente post: ¿He liberado todos los apuntadores?

Imagen:


Con lo cual considero que el problema es el apuntador devuelto por readdir.

Intente cambiar el siguiente pedazo de codigo


while(directorio_archivo_temporal = readdir(directorio) ) {
//etc...
}


por


while(directorio_archivo_temporal = readdir(directorio) ) {
//etc..
free(directorio_archivo_temporal);
}


Pero el programa se queda colgado por un rato y finaliza, seguramente por tratar de escribir en memoria que no esta asignada...

Intente implementarlo con readdir_r utilizando mi propio apuntador previamente asignado..


while(readdir_r(directorio,directorio_archivo_temporal,&result) == 0 && result != NULL){


Pero por alguna razon MinGW no lo tiene implementado, y segun he visto ya esta deprecated, entonces ¿Cual puede ser la solución?

Saludos!




Pordon por el Post tan largo, aqui esta su patata

#34
Estoy haciendo pruebas con un miniservidor, que actualmente solo lee la entrada y la muestra en pantalla.



El detalle esta en que La memoria utilizada no deja de incrementar, empieza el programa usando sobre 400 KB y mientras mas preciono F5 en el navegardor WEB, (El miniservidor es WEB), enviando Multiples GET al servidor la memoria del programa incrementa y nunca decrementa, siendo que en cada ocasion he liberado el apuntador utilizado para leer la linea, y he cerrado el socket del cliente:

Codigo:


#include<winsock2.h>
#include<stdio.h>
#include<stdlib.h>
#include <unistd.h>

#define BACKLOG 256

WSADATA *wsaData;
struct sockaddr_in *server_sa;

char *readLine(SOCKET descriptor,int *len);

int main() {
SOCKET s,c;
int b = 0,iResult;
int read_len;
char *linea;
char caracter;
wsaData = calloc(1,sizeof(WSADATA));
iResult = WSAStartup(MAKEWORD(2,2), wsaData);
if (iResult != 0) {
printf("WSAStartup failed: %d\n", iResult);
return 1;
}
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
return 2;
}
server_sa = calloc(1,sizeof(struct sockaddr_in));
server_sa->sin_family = AF_INET;
server_sa->sin_port   = htons(80);
server_sa->sin_addr.s_addr = htonl(INADDR_ANY);

if (bind(s,(struct sockaddr *) server_sa, sizeof(struct sockaddr)) < 0) {
perror("bind");
return 3;
}
b = sizeof(struct sockaddr);
listen(s, BACKLOG);
while(1) {
if((c = accept(s,(struct sockaddr *)server_sa, &b)) < 0) {
printf("WS error code: %i\n",WSAGetLastError());
perror("accept");
return 4;
}
do{
linea = readLine(c,&read_len);
printf("%s\n",linea);
free(linea);
}while(read_len != 0);
close(c);
}
}

char *readLine(SOCKET descriptor,int *len) {
char *buffer = NULL;
int i = 0,entrar = 1,len_read;
do {
buffer = realloc(buffer,(i+1));
len_read = recv(descriptor,buffer + i,1,0);
if(len_read == 1){
switch(buffer[i]) {
case 0xD:
buffer[i] = '\0';
break;
case 0xA:
buffer[i] = '\0';
entrar = 0;
break;
default:
i++;
break;
}
}
else {
buffer[i] = '\0';
entrar = 0;
}
}while(entrar);
if(len  != NULL){
len[0] = i;
}
return buffer;
}


El problema es que se espera que el servidor se lo mas liguero ligero posible y atienda millones de peticiones por segundo. Y no creo que el F5 del navegador supere mas de 100 peticiones por segundo.

Saludos
#35
Hola a todos anteriormente ya habia trabajado con sockets en C, sin embargo no estoy seguro si es mi Computadora actual la del problema:


#include<winsock2.h>
#include<stdio.h>

int main() {
int s;
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
printf("Valor %i\n",s);
perror("socket");
       return 1;
}
}


En mi caso al compilar y ejecutar el codigo anterior siempre me devuelve menos -1


C:\> gcc -o test.exe test.c -lws2_32
C:\> test.exe
Valor -1
socket: No error


El codigo original es mas extenso, pero incluso con ese fragmento basico de codigo me devulve error...

Version de gcc

Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=c:/mingw/bin/../libexec/gcc/mingw32/6.3.0/lto-wrapper.exe
Target: mingw32
Configured with: ../src/gcc-6.3.0/configure --build=x86_64-pc-linux-gnu --host=mingw32 --target=mingw32 --with-gmp=/mingw --with-mpfr --with-mpc=/mingw --with-isl=/mingw --prefix=/mingw --disable-win32-registry --with-arch=i586 --with-tune=generic --enable-languages=c,c++,objc,obj-c++,fortran,ada --with-pkgversion='MinGW.org GCC-6.3.0-1' --enable-static --enable-shared --enable-threads --with-dwarf2 --disable-sjlj-exceptions --enable-version-specific-runtime-libs --with-libiconv-prefix=/mingw --with-libintl-prefix=/mingw --enable-libstdcxx-debug --enable-libgomp --disable-libvtv --enable-nls
Thread model: win32
gcc version 6.3.0 (MinGW.org GCC-6.3.0-1)


Voy a tratar de actualizar el mingw

Saludos
#36
Realice un programa que pueda recibir parámetros desde la linea de comandos, dicho programa recibirá un directorio en el disco duro o un archivo

Si es Directorio..
  • Comprobar que el directorio sea valido.
  • Comprobar que sea distinto al directorio actual.
  • Listar los archivos y pesos en bytes en el directorio mencionado.
  • Realizar una copia de seguridad de dichos archivos, con las siguientes características
  • Todos lo archivos del directorio se deben de guardar en un unico archivo llamado directorio.dir donde directorio se debe sustituir por el nombre  del directo indicado en primer lugar. Ejemplo "C:\temp\codigos\" el archivo se debe de llamar codigos.dir
  • Se debera de tener un registro  también en archivo (index.dat), que contenga Nombre, donde comienza y cuando espacio ocupa cada archivo del directorio en el nuevo.
  • Se debera realizar también una validación tipo checkum de cada archivo, utilice el sistema Hash de su preferencia para hacer esta validación.


    Si es archivo, deberá de ser alguno en terminación .dir
  • Comprobar que exista
  • Que este completo segun la lista de archivos que previamente guardamos en el index.dat
  • Debera de Extraerlo en un directorio indicado por el usuario (En un segundo parametro al programa) distinto al directorio Original.

    El programa podrá ser creado en C o C++

    Deberá de utilizar en cualquier momento la menor cantidad de memoria posible y ser lo bastante rápido para pode competir con otros.

    El post es solo para darle un poco mas de movimiento a este subforo de programación en C/C++.

    Si tienen dudas sobre una parte en especifico, pueden de preferencia abrir un nuevo tema, con la duda en especifico.

    Si alguno quiere participar comentelo aqui, asi mismo también pueden sugerir mas features para el programa. Ya que opciones hay varias.

    La intención no es reinventar la rueda, programas similares ya existen Tipo (TAR), la intención es que quien este aprendiendo C o C++ pueda retarse asi mismo con algo que en un futuro pueda reutilizar. Y no se diga la experiencia.

    Saludos
#37
Solución

Se encontraron 2 soluciones

  • Detectar en la memoria previamente leida por fgets si el buffer de destino tiene el retorno de linea, si esi ya no hay nada en STDIN, en caso contrario aun quedan datos.
  • realizar fseek al stdin para que avance hasta el final del archivo. (Solucion gracias a MAFUS)


    #include<stdio.h>
    #include<string.h>

    int main() {
    int len,i = 0;
    char temporal[10];
    char c;
    printf("Ingrese una cadena: ");
    fgets(temporal,10,stdin);
    printf("Cadena Leida: %s\n",temporal);
    len = strlen(temporal);
    if(temporal[len - 1 ]  != 0xA) {
    while ((c = getchar()) != 0xA);
    }
    printf("Ingrese otra cadena: ");
    fgets(temporal,10,stdin);
    printf("Cadena Leida: %s\n",temporal);
    }



    con fseek:


    #include <stdio.h>
         
        int main() {
            char c;
            while(1) {
                printf("> ");
                c = getchar();
                fseek(stdin, 0, SEEK_END);
                printf("Caracter: %c\n", c);
            }
        }




    Post Original

    Muy buen dia aun que la pregunta en el titulo de este post parece una pregunta totalmente N00b. No lo es.

    El objetivo del post es Dejar de utilizar fflush

    fflush(stdin);

    Yo no lo utilizo, o por lo menos trato de nunca recomendarlo, solo que ayer se lo recomendé a alguien y no me convence su implementación.  :silbar:

    La verdad es que quiero dar por terminado el tema de la función fflush para el Buffer de entrada.

    Todo esto en Lenguaje C  ;-)

    La idea de este post viene de preguntas hechas en el foro similares a ¿Como filtrar todo tipo de datos de entrada en un programa?

    Revisando algunas links en internet me encuentro con:
    https://es.stackoverflow.com/questions/82431/saber-si-el-b%C3%BAfer-de-entrada-stdin-est%C3%A1-vac%C3%ADo-en-c-est%C3%A1ndar
    http://man7.org/linux/man-pages/man3/fflush.3.html
    http://www.cplusplus.com/reference/cstdio/fflush/

    Sin embargo en todos ellos hablan de que el comportamiento de fflush para el stdin es Inesperado, por lo cual repetidamente dicen que no se debe de usar.

    ¿Cual es la solución para limpiar el buffer de entrada, si es que realmente queda algo en el?

    Intente con feof, sin embargo al parecer NUNCA llega el fin del archivo para STDIN

    #include<stdio.h>
    #include<string.h>

    int main() {
    char temporal[10];
    printf("Ingrese menos de 10 o mas de 10 caracteres\npara ver el comportamiento de feof(stdin): ");
    fgets(temporal,10,stdin);
    temporal[strcspn(temporal,"\n\r")] = '\0';
    printf("Valor leido %s\n",temporal);
    if(feof(stdin)) {
    printf("stdin llego al final del archivo\n");
    }
    else {
    printf("stdin NO llego al final del archivo\n");
    }
    }


    El problema de todo esto radica que cuando estamos leyendo multiples valores desde el teclado, aun que lo delimitemos con fgets para la cantidad de datos que se guardaran en cada variable, el fgets , al igual que otras funciones de entrada deja los caracteres restantes en el buffer de entrada y son tomados automaticamnete por cualquier funcion de entrada de texto.




    Como ven en la imagen, en la segunda entrada de las AAAAAAAAAAAAA, se salto el segundo "Ingrese una cadena."

    #include<stdio.h>
    #include<string.h>

    int main() {
    char temporal_1[10];
    char temporal_2[10];
    printf("Ingrese una cadena: ");
    fgets(temporal_1,10,stdin);
    temporal_1[strcspn(temporal_1,"\n\r")] = '\0';
    printf("Ingrese una cadena: ");
    fgets(temporal_2,10,stdin);
    temporal_2[strcspn(temporal_2,"\n\r")] = '\0';
    printf("Valor leido %s\n",temporal_1);
    printf("Valor leido %s\n",temporal_2);
    }


    Este problema tambien se presenta en C++ con funciones de entrada tipo cin>>

    Ejemplo:



    Codigo:

    Código (cpp) [Seleccionar]
    #include<iostream>

    using namespace std;
    int main() {
    int numero_1,numero_2;
    cout<<"Ingrese un numero: ";
    cin>>numero_1;
    cout<<"Ingrese un numero: ";
    cin>>numero_2;
    cout<<"Valor leido "<<numero_1<<endl;
    cout<<"Valor leido "<<numero_2<<endl;
    }


    Entonces pregunto:

    ¿Cual es la solución para limpiar el buffer de entrada, si es que realmente queda algo en el?
    ¿Como se si es que realmente queda algo en el buffer de entrada, sin consumirlo.?



    https://albertobsd.blogspot.com/2018/11/queda-algo-en-el-buffer-de-entrada-stdin.html
#38
El siguiente post muestra  fragmentos de código en C que seguido son utilizados en los programas pedidos de Tareas en las escuelas.

Plantilla de un Menu de opciones usando do-while + switch

Descargar Menu_do_while_switch.c


/*
Twitter: @albertobsd
email: alberto.bsd@gmail.com

Buscame tambien en:
web: https://programaciontrabajosescolares.blogspot.com/
e-mail: ProgramacionTrabajosEscolares@gmail.com
facebook: https://www.facebook.com/ProgramacionTrabajosEscolares
*/

#include<stdio.h>
#include<stdlib.h>

int main() {
int opcion;
int entrar =1;
char temp[10];
do {
printf("1) Opcion 1\n");
printf("2) Opcion 2\n");
printf("3) Opcion 3\n");
printf("4) Salir\n");
do{
printf("Ingrese una opcion");
fgets(temp,10,stdin);
opcion  = strtol(temp,NULL,10);
}while(opcion < 0);
switch(opcion) {
case 1:
printf("Usted selecciono %i\n",opcion);
break;
case 2:
printf("Usted selecciono %i\n",opcion);
break;
case 3:
printf("Usted selecciono %i\n",opcion);
break;
case 4:
printf("Usted selecciono %i\n",opcion);
entrar = 0;
break;
default:
printf("Opcion incorrecta - Mensaje de Error\n");
break;
}
}while(entrar == 1); //Se puede dejar como  "}while(entrar);"
return 0;
}





Fuente: Plantilla de para Capturar Datos y Mostrarlos


Plantilla de para Capturar Datos y Mostrarlos

Usando estructura de datos y memoria dinámica para los datos almacenados.

Descarga plantilla_capturar_mostrar_datos.c


/*
Twitter: @albertobsd
email: alberto.bsd@gmail.com

Buscame tambien en:
web: https://programaciontrabajosescolares.blogspot.com/
e-mail: ProgramacionTrabajosEscolares@gmail.com
facebook: https://www.facebook.com/ProgramacionTrabajosEscolares
*/

#include<stdio.h> //Funciones printf, fgets
#include<stdlib.h> //realloc
#include<string.h> //strcspn
#include<ctype.h> //tolower

#define MAX_LEN_ALFANUMERICA_1 100
#define MAX_LEN_ALFANUMERICA_2 50
#define MAX_LEN_ALFANUMERICA_3 20

typedef struct plantilla_struct {
char variable_alfanumerica_1[MAX_LEN_ALFANUMERICA_1];
char variable_alfanumerica_2[MAX_LEN_ALFANUMERICA_2];
char variable_alfanumerica_3[MAX_LEN_ALFANUMERICA_3];
int variable_entera_1;
int variable_entera_2;
int variable_entera_3;
float variable_flotante_1;
}TIPO;

int funcion_ingreso_de_datos();
int funcion_imprimir_datos();


TIPO *tipos = NULL;
int contador_tipos = 0;

int main() {
int opcion;
int entrar =1;
char temp[10];
do {
printf("1) funcion_ingreso_de_datos\n");
printf("2) funcion_imprimir_datos\n");
printf("3) Salir\n");
do{
printf("Ingrese una opcion: ");
fgets(temp,10,stdin);
opcion  = strtol(temp,NULL,10);
}while(opcion <= 0); //Mientras sea menor o igual que 0

switch(opcion) {
case 1:
printf("Usted selecciono %i\n",opcion);
funcion_ingreso_de_datos();
break;
case 2:
printf("Usted selecciono %i\n",opcion);
funcion_imprimir_datos();
break;
case 3:
printf("Usted selecciono %i\n",opcion);
entrar = 0;
break;
default:
printf("Opcion incorrecta - Mensaje de Error\n");
break;
}
}while(entrar == 1); //Se puede dejar como  "}while(entrar);"
return 0;
}

int funcion_ingreso_de_datos() {
int opcion;
int entrar =1,entrar_opcion_si_no;
char temp[10];
do {

tipos = realloc(tipos,(contador_tipos+1)*sizeof(struct plantilla_struct)); //Incrementamos el espacio para 1 Variable TIPO mas en el arreglo

//Capturamos variable_alfanumerica_1
printf("Capture variable_alfanumerica_1: ");
fgets(tipos[contador_tipos].variable_alfanumerica_1,MAX_LEN_ALFANUMERICA_1,stdin);
tipos[contador_tipos].variable_alfanumerica_1[strcspn(tipos[contador_tipos].variable_alfanumerica_1,"\n\r")] = '\0'; //Reemplazamos los retornos de linea con caracrer nulo, terminador de cadena

//Capturamos variable_alfanumerica_2
printf("Capture variable_alfanumerica_2: ");
fgets(tipos[contador_tipos].variable_alfanumerica_2,MAX_LEN_ALFANUMERICA_2,stdin);
tipos[contador_tipos].variable_alfanumerica_2[strcspn(tipos[contador_tipos].variable_alfanumerica_2,"\n\r")] = '\0'; //Reemplazamos los retornos de linea con caracrer nulo, terminador de cadena

//Capturamos variable_alfanumerica_3
printf("Capture variable_alfanumerica_3: ");
fgets(tipos[contador_tipos].variable_alfanumerica_3,MAX_LEN_ALFANUMERICA_3,stdin);
tipos[contador_tipos].variable_alfanumerica_3[strcspn(tipos[contador_tipos].variable_alfanumerica_3,"\n\r")] = '\0'; //Reemplazamos los retornos de linea con caracrer nulo, terminador de cadena


//Capturamos variable_entera_1
do {
printf("Capture variable_entera_1: (Solo mayores que 0) ");
fgets(temp,10,stdin);
tipos[contador_tipos].variable_entera_1 = strtol(temp,NULL,10); //Solo procesamos numeros BASE 10

}while(tipos[contador_tipos].variable_entera_1 <= 0); // Salimos del DO solo si el valore leido es mayor o igual a 1

//Capturamos variable_entera_2
do {
printf("Capture variable_entera_2: (Solo mayores o iguales que 0) ");
fgets(temp,10,stdin);
tipos[contador_tipos].variable_entera_2 = strtol(temp,NULL,10); //Solo procesamos numeros BASE 10
}while(tipos[contador_tipos].variable_entera_2 < 0); // Salimos del DO solo si el valore leido es mayor o igual a 0


//Capturamos variable_entera_3
do {
printf("Capture variable_entera_3: (Solo Negativos) ");
fgets(temp,10,stdin);
tipos[contador_tipos].variable_entera_3 = strtol(temp,NULL,10); //Solo procesamos numeros BASE 10
}while(tipos[contador_tipos].variable_entera_3 >= 0); // Salimos del DO solo si el valor leido es negativo

//Capturamos variable_flotante_1
do {
printf("Capture variable_flotante_1: (Solo distintos que 0) ");
fgets(temp,10,stdin);
tipos[contador_tipos].variable_flotante_1 = strtof(temp,NULL);
}while(tipos[contador_tipos].variable_flotante_1 == 0.0); // Salimos del DO solo si el valor leido distinto de 0

entrar_opcion_si_no = 1;
do{
printf("Desea segir ingresando mas datos? (s/n)\n");
fgets(temp,10,stdin);
switch(tolower(temp[0])) {
case 's':
entrar_opcion_si_no = 0;
printf("Selecciono SI\n");
break;
case 'n':
entrar_opcion_si_no = 0;
printf("Selecciono NO\n");
entrar = 0; // Se cambia la variable para salir del menu principal
break;
default:
printf("opcion incorrecta, solo 's' o 'n'\n");
break;
}
opcion  = strtol(temp,NULL,10);
}while(entrar_opcion_si_no == 1);

contador_tipos++; //Aqui incrementamos el contador_tipos que indica cuantos valores completos tenemos de la estructura plantilla_struct
}while(entrar == 1); //Se puede dejar como  "}while(entrar);"
}

int funcion_imprimir_datos() { //Imprimir los datos no tiene mucho sentido, solo hay que recorrer correctamente la cantidad de registros previamente capturados
int i = 0;
while(i < contador_tipos) {
printf("Datos del registro %i\n",(i+1));
printf("variable_alfanumerica_1: %s\n",tipos[i].variable_alfanumerica_1);
printf("variable_alfanumerica_2: %s\n",tipos[i].variable_alfanumerica_2);
printf("variable_alfanumerica_3: %s\n",tipos[i].variable_alfanumerica_3);
printf("variable_entera_1: %i\n",tipos[i].variable_entera_1);
printf("variable_entera_2: %i\n",tipos[i].variable_entera_2);
printf("variable_entera_3: %i\n",tipos[i].variable_entera_3);
printf("variable_flotante_1: %f\n",tipos[i].variable_flotante_1);
printf("\n");//Enter adicional
i++;
}
}
#39
Fuente: ¿He liberado todos los apuntadores?



Para aquellos que les guste programar con memoria dinamica en C, frecuentemente se encontraran en ocasiones tener la sensacion de no haber liberado un apuntador, esto puede ser cuando tambien trabajamos con arreglos (longitud variable) de apuntadores.

Para facilitar esta tarea se pueden programa sus propias implementaciones que lleven un conteo de cuantos apuntadores se han creado y de cuantos se han liberado.

Si al final del programa el resultado es 0, entonces pueden estar tranquilos de que todo se libero correctamente.

Esta sencilla implementacion, solo lleva dicho conteo, NO lleva conteo de memoria utilizada y/o control de cuales apuntadores ya fueron liberados, eso ya es harina de otro costal.


#include<stdlib.h>

unsigned int N_ptr = 0;

unsigned int test_result() {
return N_ptr;
}

void *test_realloc(void *ptr,size_t size) {
void *ptr_new = NULL;
ptr_new = realloc(ptr,size);
if(ptr == NULL && ptr_new != NULL){
N_ptr++;
}
return ptr_new;
}

void *test_calloc(size_t nmemb,size_t size) {
void *ptr = NULL;
ptr = calloc(nmemb,size);
if(ptr != NULL) {
N_ptr++;
}
return ptr;
}

void *test_malloc(size_t size) {
void *ptr = NULL;
ptr = malloc(size);
if(ptr != NULL) {
N_ptr++;
}
return ptr;
}

int test_free(void *ptr) {
N_ptr--;
free(ptr);
}


Se podrian sustituir las funciones malloc, calloc, realloc y free en nuestro programa hacia estas funciones para testear y exclusivamente para prueba. posteriormente volver a dejarlas llamadas originales.

Al final del main despues de liberar todo podremos colocar esta linea

printf("Valor %i",test_result());
Si en nuestra salida del progrma el resultado es 0, significa que todo esta bien.

En caso contrareo, deberemos depurar en nuestras subfunciones el antes y el despues de cada llamada para validar en que función esta el problema.

Saludos
#40
Muy buen dia.

Dejo una implementación en C, le faltan muchas funciones, ahorita solo realiza Sumas, se podriasn optimizar muchas cosas, pero hasta el momento ahi esta.

bigint2.c

La funcion mas interesante es la de valor(), nos devuelve un apuntadora a un structura tipo numero.


typedef struct numero_struct {
unsigned char *valor;
unsigned int bytes;
}numero;


Dicha función transforma el arreglo de caracteres NUMERICO y en FORMATO DECIMAL POSITIVO a dicha estructura que mantiene en MEMORIA el valor BINARIO que dicho string de entrada representa.

Basicamente, Calcula y Guarda en un archivo para futura referencia y uso, los valores 10 exponenente (N) donde N va desde 0 hasta el maximo numero necesario para calcular el valor binario del string dado.

Funciona correctamente con cualquier longitud del string, lo he probado con cadenas de hasta 100 mil digitos. Lo cual es muy lento la primera vez, pero despues de calcular las potencias base 10 los futuros calculos los realiza mucho mas rapido.

Algunos ejemplos son:

el numero 9508906499
de longitud 10 necesita 5 bytes
Representacion Hexadecimal: 0236C66603
el numero 79026753228
de longitud 11 necesita 5 bytes
Representacion Hexadecimal: 12665C8ECC
el numero 933649574924
de longitud 12 necesita 5 bytes
Representacion Hexadecimal: D961D9EC0C
el numero 9989430590552
de longitud 13 necesita 6 bytes
Representacion Hexadecimal: 0915D8763C58
el numero 38062317126925
de longitud 14 necesita 6 bytes
Representacion Hexadecimal: 229E12E4450D
el numero 296949875619078
de longitud 15 necesita 7 bytes
Representacion Hexadecimal: 010E1307DA3506
el numero 7684940238559364
de longitud 16 necesita 7 bytes
Representacion Hexadecimal: 1B4D69950A1884
el numero 30277955788415107
de longitud 17 necesita 7 bytes
Representacion Hexadecimal: 6B91A3EF4B2083
el numero 443538258076866400
de longitud 18 necesita 8 bytes
Representacion Hexadecimal: 0627C3B21CF79760
el numero 5110845141847637729
de longitud 19 necesita 8 bytes
Representacion Hexadecimal: 46ED5E93FDDBFEE1
el numero 76591288655576173975
de longitud 20 necesita 9 bytes
Representacion Hexadecimal: 0426EAEB3BF5060D97
el numero 493487708389371607340
de longitud 21 necesita 9 bytes
Representacion Hexadecimal: 1AC084882B920CF92C
el numero 9668897885521969420983
de longitud 22 necesita 10 bytes
Representacion Hexadecimal: 020C26E9C6DD9E841AB7
el numero 04135218222328126908806
de longitud 23 necesita 9 bytes
Representacion Hexadecimal: E02BAE57E1DE4C2986
el numero 639256514613014991622338
de longitud 24 necesita 10 bytes
Representacion Hexadecimal: 875E2A43BA5D98BE50C2
el numero 2089496886779378553412856
de longitud 25 necesita 11 bytes
Representacion Hexadecimal: 01BA77DA6B78DF76315CF8
el numero 14562279752234396367030462
de longitud 26 necesita 11 bytes
Representacion Hexadecimal: 0C0BAEC466485FA68588BE
el numero 265502188807599622290669420
de longitud 27 necesita 11 bytes
Representacion Hexadecimal: DB9E467EC83B81038FFF6C
el numero 2107115540939520793071876728
de longitud 28 necesita 12 bytes
Representacion Hexadecimal: 06CEF7125BB4F3D32DF47A78
el numero 17034677710437334747912105699
de longitud 29 necesita 12 bytes
Representacion Hexadecimal: 370AC1510FF4B7C59FB46EE3
el numero 769845887298081235582665565779
de longitud 30 necesita 13 bytes
Representacion Hexadecimal: 09B78197B6616A045D8BAF2653
el numero 7752931137310735604161360693253
de longitud 31 necesita 13 bytes
Representacion Hexadecimal: 61DB1253C623FF1908F6EC0805
el numero 62908878285305979688345459351332
de longitud 32 necesita 14 bytes
Representacion Hexadecimal: 031A058C799DBEF3FC6FE1F5DF24
el numero 393307676431630231318919462734028
de longitud 33 necesita 14 bytes
Representacion Hexadecimal: 13643DA4B667F76326B843DF48CC
el numero 9286742727091217435872337894524547
de longitud 34 necesita 15 bytes
Representacion Hexadecimal: 01C9DF2C219E20CC41D19E29434683
el numero 81426020823826464275628408184790074
de longitud 35 necesita 15 bytes
Representacion Hexadecimal: 0FAE9CDF36CEF0CDB99B4E9C5C5C3A
el numero 552090705523052467602459604258802839
de longitud 36 necesita 15 bytes
Representacion Hexadecimal: 6A542C612B644A58F6B6DA564A4C97
el numero 1607007686413736857390231788165105058
de longitud 37 necesita 16 bytes
Representacion Hexadecimal: 01357F989C79237F6ECED5CA006985A2
el numero 84527556878939029259981059502779573085
de longitud 38 necesita 16 bytes
Representacion Hexadecimal: 3F976A5091FBACA3FD3FC3B24BFEA35D
el numero 056122036719126405392509234100546035540
de longitud 39 necesita 16 bytes
Representacion Hexadecimal: 2A38B60B068A7DD916BB8212C0CFDF54
el numero 1397797302207950391505993651678902880708
de longitud 40 necesita 17 bytes
Representacion Hexadecimal: 041B95F7D229FDF2B63BB34068C01E09C4
el numero 18746744536569357864430590925898233101997
de longitud 41 necesita 17 bytes
Representacion Hexadecimal: 37177BAA910AE65C788461E172EFBB3EAD
el numero 804894583183669821728339691589385846084005
de longitud 42 necesita 18 bytes
Representacion Hexadecimal: 093D5F61FB9C23E365D88C0CFED2F73551A5
el numero 2819911651438636304992057938438785329811469
de longitud 43 necesita 18 bytes
Representacion Hexadecimal: 205EF9BD00D29343258B03E61E006C4C500D
el numero 51838952794997591750046971903020085981735827
de longitud 44 necesita 19 bytes
Representacion Hexadecimal: 025314FD8B5B319A9E50F4DCBED28E4907EB93
el numero 554667750646910147605914892445216353582660927
de longitud 45 necesita 19 bytes
Representacion Hexadecimal: 18DF4604C7ADFFED701605FD59EB34782D3D3F
el numero 7526062665713647219248740894052778487690015050
de longitud 46 necesita 20 bytes
Representacion Hexadecimal: 01517AF65E63460E9E2E67ED8FD3E8DB8843B14A
el numero 29276985507934250405288436691156195566060648304
de longitud 47 necesita 20 bytes
Representacion Hexadecimal: 0520D34FAF282C0E11C08B361DDBB714D1F53770
el numero 830805839940409446947448814738990382864691298522
de longitud 48 necesita 20 bytes
Representacion Hexadecimal: 91869F50B3465A9057749B99B2DCFB87C09700DA
el numero 7931926507328373543263398771701661038393888501417
de longitud 49 necesita 21 bytes
Representacion Hexadecimal: 056D5FE2C94151A334B6BAC058E4CB753BF9526EA9
el numero 27109589208201152976833273853366277867073628465460
de longitud 50 necesita 21 bytes
Representacion Hexadecimal: 128C9405F2621D9463915E513E805431F54F7EE934
el numero 296232053173620093505668395967855847034981065582972
de longitud 51 necesita 21 bytes
Representacion Hexadecimal: CAB0B0ADA331DC13DCA889B8D9F264F8D2DF1A697C
el numero 7205621497077436120372829822602284232166470146450890
de longitud 52 necesita 22 bytes
Representacion Hexadecimal: 1342494AD3D96689D1BA563CAF515D3481DB2305E5CA
el numero 00770727121893243130126529201326945841205884858949629
de longitud 53 necesita 22 bytes
Representacion Hexadecimal: 020F5A576F2F91D902A0EC1BFDDF20115CF056E05FFD
el numero 723316096918316204638533229591528026587621099674968147
de longitud 54 necesita 23 bytes
Representacion Hexadecimal: 078D40F4FAA867408F4E86C11C5A65FC53C6167DCEA053
el numero 5805333328562460191851457989006630480930046300126682198
de longitud 55 necesita 23 bytes
Representacion Hexadecimal: 3C9C4A40C6AA04A21B7D3B8290C6DC5EF29B32B6F79C56
el numero 91012498956437519451038300434423814267498816054781401400
de longitud 56 necesita 24 bytes
Representacion Hexadecimal: 03B636FED1C0A31F024EF2F083741A488476DFADE68DD938
el numero 904887522290051813525477187920948803392914571359930655281
de longitud 57 necesita 24 bytes
Representacion Hexadecimal: 24E7776FA977A004417FEB52A6E13C87471DC778BB69A231
el numero 6919564797676194198404327128602009090582747667529614366295
de longitud 58 necesita 25 bytes
Representacion Hexadecimal: 011A33A099B576DCEE974EB626EF2DA6EF82ADEA61335A1657
el numero 26735323785302410963392632172845083014323669659798657356204
de longitud 59 necesita 25 bytes
Representacion Hexadecimal: 044259CDED1E60C3237FCF73C9133A5F93AF9E51B04E40D1AC
el numero 635206334832806694337649250750217328273194184092661694549751
de longitud 60 necesita 25 bytes
Representacion Hexadecimal: 6531B7935E3DF284AF44937FE48BCC7E6D9742F1A69C774EF7
el numero 5824782255290762743314240538068791947763695634019364415603505
de longitud 61 necesita 26 bytes
Representacion Hexadecimal: 039FF0FC47E991CD542FDEE5726C38631C27B37A743317120331
el numero 87883150612468093200977892868513357832600491656991793681015346
de longitud 62 necesita 26 bytes
Representacion Hexadecimal: 36B097F890B8D83A251C252243359699D755D191B0AF0E802232
el numero 012751938784461219311159264627588297581963494266867033901015259
de longitud 63 necesita 26 bytes
Representacion Hexadecimal: 07EF8045005D29A2F8B9C1DC2DE17CA4F3C429AA43A949C6A0DB
el numero 5995716985849551023542218631287142274829254660354648190502069165
de longitud 64 necesita 27 bytes
Representacion Hexadecimal: 0E9324D2BA970741B9F0C8B78CD5EC0ABFC1E6F882206D14AC63AD
el numero 14718675857634742143675119548297441494532017584141228529011591019
de longitud 65 necesita 27 bytes
Representacion Hexadecimal: 23C774585AF41EE65D76B9740D2BDF0A6B9E7FB5E21CCF78A3076B
el numero 590982903070714532432208534154332065777095106757771386683419547782
de longitud 66 necesita 28 bytes
Representacion Hexadecimal: 059C99903FFCEA7CC4A53E9873BA57245DFAF4C2EDB3D66351A45886
el numero 6223457355228217126421204446150586144423466821232162381396393141432
de longitud 67 necesita 28 bytes
Representacion Hexadecimal: 3B186305306E5867600FEF2A98B2357132E1118C971A9FA21DE524B8
el numero 11515476695966006750961184952414936750695004617724296309560906536454
de longitud 68 necesita 28 bytes
Representacion Hexadecimal: 6D5892BDB7BFCB04A835E8677040D9609DE2059FC09BDBBC9BD2D606
el numero 066836638706652624251250427257737934194942333795820249017570955151464
de longitud 69 necesita 29 bytes
Representacion Hexadecimal: 027AA6DE6115C5976B471B2C1A74B704171510B588EABEBFE077CCC868
el numero 9443735029791929993690448592971064100368932274636209615179629480281612
de longitud 70 necesita 30 bytes
Representacion Hexadecimal: 015E49A0310BF89FDEFA60C470C796D140490ABD79E9BB2A4F14C85E860C
el numero 57869586247997806265551637733342225464641419261542117350159267352143329
de longitud 71 necesita 30 bytes
Representacion Hexadecimal: 086280939E7AB5DA0000C274FE4FC7D9F0278703B1B5FF5448B78DC9E5E1
el numero 162456256602286307539596247171019101979404693318168923877172013603063460
de longitud 72 necesita 30 bytes
Representacion Hexadecimal: 1789D663EA040942C70F7388ACF6696931FB1156BDA0DBD844AC2A4586A4
el numero 0152863367815219021395300267029850969550051595226908371041722482605359721
de longitud 73 necesita 30 bytes
Representacion Hexadecimal: 1626047705F106D4A1093EFFEE6BEB4669C219EFA4A61A574B9BCA430269
el numero 90902667586688622651765328005814061810460874268469409448596473755638747913
de longitud 74 necesita 31 bytes
Representacion Hexadecimal: 3372F75656F59C221A26256E9C21BF41453943D32381727CBFF92F6450D309
el numero 960287807572918872306866613466498010023757874493946386696753468762266767043
de longitud 75 necesita 32 bytes
Representacion Hexadecimal: 021F80EE6C3C5D6E7C1805C7533403AE2F1CB990B7913260AFC6BDC9E3638EC3
el numero 4623683211960443491409149829656196249450541531985178037211638509941946023540
de longitud 76 necesita 32 bytes
Representacion Hexadecimal: 0A38E976161A478AC836EFF42AFF652A206126BB8D923E899F383A4C41CB7E74
el numero 11885775098325312928491248506396285879335713629412691345234491347083643517856
de longitud 77 necesita 32 bytes
Representacion Hexadecimal: 1A471C3D0103499CE51B532312D84F50C0EE57F5932E49F6F59DEFB9F806FBA0
el numero 680969134587510658403000187458299170848405271116781608018185317819577313351618
de longitud 78 necesita 33 bytes
Representacion Hexadecimal: 05E186DF2067212C5F0F81604268840E8FC40F6B22074802672F19EF2F86F157C2
el numero 8476729882745397134482385713794002120248709935355420315792554700372291965408781
de longitud 79 necesita 33 bytes
Representacion Hexadecimal: 4934DB174BF36F0F277C29417ECF933EAADB2C146B3FE6036399DCA2D30187D60D
el numero 10657407842193926828174073657547116606438390771632735643113222328705112961719599
de longitud 80 necesita 33 bytes
Representacion Hexadecimal: 5C0A0713B2802FCF216753052ACF9B29BF794CB920B0F58435811CEA36EE481D2F
el numero 848384984720582276524149050276752584127778173923632107088683809879446490516758311
de longitud 81 necesita 34 bytes
Representacion Hexadecimal: 1C9ECBB4CECC60C0584A01ED41025886F7E81A9773C1B6F529CCE92B85E1B21B1F27
el numero 3328022865011124331134422450484417506321495203783071049232384867852273549457711107
de longitud 82 necesita 34 bytes
Representacion Hexadecimal: 70455DCD889C5CDE8A9B8D9C1DBEF954BAF6910BF191B82835D7631A8744FE8F6003
el numero 49424895807173676782318665174906876100230699278133756809763093842917383886495320725
de longitud 83 necesita 35 bytes
Representacion Hexadecimal: 068359BB23636776CBA7A109F7306CAFD8A17B1528CCE33C37AF6AED346F1E37408A95
el numero 787960467817664059270211145988438104280119156627453798381517142088632121846172312128
de longitud 84 necesita 35 bytes
Representacion Hexadecimal: 67D5DF6A31EEDED6F55199B6DF2E4708EB3F1B2C9BF4A24ACA0A0A06F0A69C43FD6240
el numero 5824920117794887292575398052801340440312111359822553607851773223894542017641046559581
de longitud 85 necesita 36 bytes
Representacion Hexadecimal: 02FF97DFF50D7FD66EEBEC44A28F6654B5ED468B3DDEC85D6A75A381271CCAD1D62B4B5D
el numero 35236969272141423150445053180738284791568752951164698625673919988173330348625010609181
de longitud 86 necesita 36 bytes
Representacion Hexadecimal: 122370560140ECFEA77D0EDC5205E7A535A9DA7DFE12387B37F67855EB7798776CDFCC1D
el numero 991681457933650945209048671140407197854249558628551854468033088478802164952381930335921
de longitud 87 necesita 37 bytes
Representacion Hexadecimal: 01FE79471FAD4374D7663B4BC5EBCBD76BC21D2C70F07B2A6F33D4993A66AEA02B97D7EEB1
el numero 3636118606510581020072373891577171424450194452728623119023924909489946084038386927238799
de longitud 88 necesita 37 bytes
Representacion Hexadecimal: 074FB686B423F8759CFB525542BC49BB5DA1AA2EEFF19552936982732B4D75BC8A54737E8F
el numero 21825623602137192883344731612452607124969991485395771384519453488675305781257970548690602
de longitud 89 necesita 37 bytes
Representacion Hexadecimal: 2BE2DD8D981AB7EA3CCA0DF630F3BFB982475FED6902EB6244B9C864D159B2C119C2834EAA
el numero 822415088582966034681923336484158762762317466063728101719023317259452607495867616761509315
de longitud 90 necesita 38 bytes
Representacion Hexadecimal: 0675AEE731176C680694EFC00E6505A43DBA55A963DC00D553B68461B1714CF8FC96444C75C3
el numero 0288654549061197882131379213607717342718858225953430416012758405566356903511399668323973152
de longitud 91 necesita 38 bytes
Representacion Hexadecimal: 02446A976AEF48A687B50C06306E211A0A7202AC142ACBDD1EED9B117A35B943CCF576EFF820
el numero 63966771755697121728991103275594286809502308291696493635920004127380109213734902869009676065
de longitud 92 necesita 39 bytes
Representacion Hexadecimal: 01F66E2024799EF14CA1C9BB195F2FA16A879ACB53A8082AACBB50BC99057838037AB92810B721
el numero 506206336294691994750144863037697012719868159707420221432013452605634047447925100556369973002
de longitud 93 necesita 39 bytes
Representacion Hexadecimal: 0F8805D2D2B3B6AFAF74660B5AE368A56B07F81C43D8B06B46BD39A1DFBDD21459D61F24EECF0A
el numero 6125074310607296201960374153285085756331646879219380442496014439609452200916181781223460623872
de longitud 94 necesita 39 bytes
Representacion Hexadecimal: BBEDB31B5CBABAC2FCCDE0A55C3EDDF388B1D043204D20DE5305E6923B3B246345022C0E04D600
el numero 61833944625328675440032268921010583843543718809601381156167366663661265720250279391541860477818
de longitud 95 necesita 40 bytes
Representacion Hexadecimal: 07692DC8164920171C7E9E9ABE7AAAD397AC2908711E004B81F5839DA253F098E4BDBFBA907FAB7A
el numero 571574829102676832166987221188186898566150579269385065901199285411819856602318969913145768388316
de longitud 96 necesita 40 bytes
Representacion Hexadecimal: 4480F6D045A33806E704DCD8752C405978C7D864E1F17D7B43992CDD4004A5F180BBD1E8C6F9A6DC
el numero 2588166834440807184111009187748818742303001716886497760100601436910371360466659740471267042884282
de longitud 97 necesita 41 bytes
Representacion Hexadecimal: 013631B4A16785A52B5A8E66C4863AB3ED0CD0A169146231E77367142C1E24276DF513D20EFC257ABA
el numero 08399377912193651211670109524222926953117565257894780317383096009063246377844243527605772528322138
de longitud 98 necesita 41 bytes
Representacion Hexadecimal: 03EEAC51F44041738542321237B59960E84C336CFA73DA8AFD8FB1F96547EBEA81B76F6B82416B065A
el numero 939469214211150135700554629471917754377476629856163844126156127004135631666726634496001821629184650
de longitud 99 necesita 42 bytes
Representacion Hexadecimal: 01B7D43EA0882121022F4B931BB7BB2AF85E61BFEB02EBE0611E09CAA48BB22014817202E10DBB8F7A8A
el numero 7945670064451112133599976408122393101132918872919385356860726014142470178349182715906596076700964030
de longitud 100 necesita 42 bytes
Representacion Hexadecimal: 0E87E7D3314B407985A7B5F3CEB8C14D096E99DEC89C6BC93EA13742B16F29C8A2CD78A7FA90299214BE
el numero 16929857392175294987462856059073655048840944672233564540984502827130961394599131980167641073486242493
de longitud 101 necesita 42 bytes
Representacion Hexadecimal: 1EF602E4D3C29F2D5360313D09F8AA217EC945C34EC06C759B9A455778049AB158D023977587C899A2BD
el numero 806715067976753408120240300580238173820439202451747672641499225622454801071163866153517658672814407932
de longitud 102 necesita 43 bytes
Representacion Hexadecimal: 05C34DE2C88306BA34CCDACBE901DCCF724FBBECB0392B5D399B85382E9F8C4A2285E0978D95CC3B04C0FC
el numero 1822743757919591007181563906726748481431290666967246366322447171829380652761638770896191980400402074420
de longitud 103 necesita 43 bytes
Representacion Hexadecimal: 0D0565A29D3874E8FC587462D7A83EE9B40684E53D0FF4121BB381EBB94B22911B17626DFA6A21930D8B34
el numero 31739197338982086545684522489061084046266245962099819608056874958588292407402986816109645505650091272397
de longitud 104 necesita 43 bytes
Representacion Hexadecimal: E2BC00F84A331FCCA543C721A6AE54820C44E2783DBD9FCD7416FF5EDDFAC56AD8317F1B9432A20BC6A8CD
el numero 174144625466300741802933499188812766627996026059511781381454677939864329454791254146069265560269687128347
de longitud 105 necesita 44 bytes
Representacion Hexadecimal: 04DC082D88C35B3ED412938097C9FDCE0A1E5EE81BC778F2AC802F19CCDBB2A0B593EA97A15F1DABB05C811B
el numero 2262425314428260681910706404228228285058417704936214425994154697665872706770252084779212634010199722682991
de longitud 106 necesita 44 bytes
Representacion Hexadecimal: 3F2205C5E1AF8E1AC82E519236E1D3996F595F6F2007B757A19393301DD5BC1AB99FCC58369135E3A621EA6F
el numero 84741558901205037781869494734310535474077789669530059340455274758338924097554434471862833976036074245703944
de longitud 107 necesita 45 bytes
Representacion Hexadecimal: 093CB5D558C0B6462317554465B3588FAA7BC5AA0F4D16F1C6FB6C4DCF5703C1BB87B841BD0E75A967B785C908
el numero 403103100074708617795365769733208569274314121554520364435292234729145689160624624142920995073035546176482224
de longitud 108 necesita 45 bytes
Representacion Hexadecimal: 2BF094013C49E3664809EA8F1BBCE012D6EAC11269F6BE75D4F9416EA847DA23A43ACC8B588B66C2DDB07F6BB0
el numero 3002029485688953385172033799898703563586194423431029423529313809185900540398837877942458230053418852828196512
de longitud 109 necesita 46 bytes
Representacion Hexadecimal: 01473B8790A3E01BDB0BC1DA05CD0D42C12ACA2425E7CB253A1C26B9260B34783DF6BA9ADE2E9DE3A0CF073A2EA0
el numero 64355482377641161379171094254465711947444083880646685120528941224571406635470726677910038428016728913265892300
de longitud 110 necesita 46 bytes
Representacion Hexadecimal: 1B66FD85BC0D4EDE242D0EB4CE7E326F8CD41E420937200D199B2A6E235C2E604EE8EE8D1188CAF766B7E1A11BCC
el numero 159296811964540873660804027111846139132062136280377179326146634123264925989332087768190039816523606715000020782
de longitud 111 necesita 46 bytes
Representacion Hexadecimal: 43D3F40F2B1807347E6305EE850173EAB46E8F406D01152727C4F6803C281243C82ABE478AA5F62ED74C30B5DF2E
el numero 2789496304465229836824207249810067374858591249850588866272082419682091695335823525694898309699931336273280813542
de longitud 112 necesita 47 bytes
Representacion Hexadecimal: 04A3C19E70339D94EF7DB1CB1F1DB323231A6E5800E6D0E45D8065557D81DFF7F90C0621671667E474BE6EAE82C9E6
el numero 15327508346853604459494116742302272778675136671271972942353491377838461177920535630258566325868729725683839524859
de longitud 113 necesita 47 bytes
Representacion Hexadecimal: 197E6439446BFE97EE94846198C6830D97A66934D7B4AFEE8A6EBEB45544CDE67457D1F5BF76F15CC36E1F1EEBDFFB
el numero 850991145714920497219887032008455290392275105153172520275692989915077088629616777953387512972436719004709704562554
de longitud 114 necesita 48 bytes
Representacion Hexadecimal: 05876C9CBD71521C6E66E517B4FD9C41A04C76D275EB4C609990D107D67738F20D0965042420C17BF043DCF2AF95F77A
el numero 9738524261642947459052203183597729916197055493153123931203754287214891619677053888459682781114831112736315925615717
de longitud 115 necesita 48 bytes
Representacion Hexadecimal: 3F45C0854CBB190B474BACFB41282DBD0989A1195C1FA26B000892FBBFF2A0644366DF0FBB538883307904157DE45465
el numero 86958995267193503893300172592881348913805567903623382116164262115633599369764991044274883772883498759035569376525562
de longitud 116 necesita 49 bytes
Representacion Hexadecimal: 0234FBE6F51FD37F997A3E45800BB61E2061BB537A52AA9684A9FB07A57FA148C87F94FFC940524BFAA62EEFDCEAFAFCFA
el numero 903918978468082824458182825132316467208381152426673989820819968348700528176219098502568682898757928966652859619374339
de longitud 117 necesita 49 bytes
Representacion Hexadecimal: 16F0E14EE4D1F87C97F1A0C04F632C647BE07B5020734A940B5C1D2DC651569B927FC99B7D77182AD06DCEE7CC6A5A7503
el numero 8858498445518311422449967522493752453090569621158175825900113073792685695066977759040260806646446185710462597082784437
de longitud 118 necesita 49 bytes
Representacion Hexadecimal: E0D2D3666110A32A9F422F0AB5790881CF047324546EB78D248F0F0505AF2A61139827B9EBFDFDBD990EEF72554D5622B5
el numero 18106018158297383708493658736106755544546663752078945717337834763842067884667125707372089039612774046139620639346232426
de longitud 119 necesita 50 bytes
Representacion Hexadecimal: 01CB852C7A0C8216412AA5B912F498148D601B5079274CD43A32338F169ED7F3D130915D63D9558AB8F9E944C4C6FB438C6A
el numero 136179195279882119345925293329234489027844683835125252947376225860774011940947956246573856767999405727343890861694727262
de longitud 120 necesita 50 bytes
Representacion Hexadecimal: 0D802615D6A2F57B6742DA9CE0945A037B2B7FE1EA0D3909367D8C20B771451DB5249059C3285D8FED0812F182F69BED345E
el numero 6832855740034826463337960297334439604773299838416098771919750199069567294898969377636623071752141505059065006518811630726
de longitud 121 necesita 51 bytes
Representacion Hexadecimal: 02A565E78DF3BF13E90F9CB31B3E85D36EC50FB1D34FEA1EC0C3E59281B92B607515A45EDB3EE536E30D86E6F1C72A48861C86
el numero 57611639487480310555596153617586912334875538207889305730009495152112318378692697706836148866559571892549626038102173816898
de longitud 122 necesita 51 bytes
Representacion Hexadecimal: 164F85E6D6DFE463C4C1FE579CFF7E0D84575A5611B8DA9660CC080A1CF1901C7761654C095BEE4E9F1B7DA29E3F8929E21842
el numero 035561068532081928616863696972231044538315781206742261642722426972170135056751444167713515101891246664425774652566709368058
de longitud 123 necesita 51 bytes
Representacion Hexadecimal: 0DC5773C6F3A3EC518E7F06D038E694F95CB0CF829C9D5013F3BA1F2C7A0BB323B6820D721A2E4FA5F40E80FB1ABCF791274FA
el numero 7883781526635879865501036610614415018220239563097526888102922631446174034437621457269384392403326940286935942747063628619729
de longitud 124 necesita 52 bytes
Representacion Hexadecimal: 0BED111DBA203C86CB7B0A9156CD275DE50A82BA99F3FE55C65E1A966ADF51E50653ABBF85CFE5663308994BDD48125A119C5FD1
el numero 16643549203387236297779837954488540870630213104878052837365585447391579796820592952259127526806660526087762280955654981216742
de longitud 125 necesita 52 bytes
Representacion Hexadecimal: 192D5E0E726D4A1A6DF48AA19556C3BFD555D1FF1EC770ED2610983E971292DAEDD0EEE2A3860AE9BB3E264BB2EA207552D2E9E6
el numero 595747650188687069004589900852664168928890018997127099714154606017193933469551404352746812606945771503557506967975331063230939
de longitud 126 necesita 53 bytes
Representacion Hexadecimal: 038534C0DAF6AC9D7031E4DDDB05BA3CACCC2C6DF90E82E91594908F18FEFABD437850F483DCA2D5149A0B331C5A9D5C85EC2571DB
el numero 7193432657552132247791855211679742505804480161009622832963522327304086275855564966556269314298078263386299615332482168845745463
de longitud 127 necesita 53 bytes
Representacion Hexadecimal: 2A81BAEA3B247C1B399AD69B5AD5B9A5A9CF3844088A7B17715310E204354739D74374DFD422D295C42735AE35D9A7387A204FBD37
el numero 08138452491122926431889872670041328150527802636563024742599920313852230050818279103520840560763157848990542340906313248829995733
de longitud 128 necesita 53 bytes
Representacion Hexadecimal: 30174A881A44344DB3A921DB47FA357246C05C24B271CD7BEF93A02C049B4BBC82DEED6092FCD9BBB2722F9C9FA9863DCD194DFAD5
el numero 806732103077060984112408141623997688893658477344545394991872554338813738775450635198174918925991143801774296635464263337400260411
de longitud 129 necesita 54 bytes
Representacion Hexadecimal: 129F10D5FB892380BB9D39B97E674DC4F73127AF3F9660A87EE61DA3754BA894E2E788757670E2C1A5D4AABF615AC6C64BDBB806D73B
el numero 8258477713511885013161831502961917612300673121536557760858095929939711236969300877461995648796643943213412842508757417958657906703
de longitud 130 necesita 54 bytes
Representacion Hexadecimal: BEA0390A3B1EF3D54AB87A5E90E16A732279010B248F068819C3B1C8E2D390F385885A0BAA642A7674A2D620F647841D5FC91CFE580F
el numero 26710069032597938520042886857930623920924786905442227283988055378310336697684819053846883318021073436830263726242667981360219583763
de longitud 131 necesita 55 bytes
Representacion Hexadecimal: 026888A33A12126008FB748B8691C7DE207F40DE0B4B5EFFA34C993B16BD346FD3B7703051774453801483AFD751F76C1DCC3339C07513
el numero 194049230193662900752834079418310242545739298627473769030256901769508337098928219064056575132661288518769321798437711935365076863159
de longitud 132 necesita 55 bytes
Representacion Hexadecimal: 117F2188191241C4D202560CA445F96C21A4C4AB9CF367C984F5B441CFF45541E4D9C9AA681FDDBA08C809D33B68AC7119476347E5C8B7
el numero 1645973768833663353115244967216999611128170069642292822619410026525941069720117529463535758197930514070222230051940178099556393741113
de longitud 133 necesita 55 bytes
Representacion Hexadecimal: 946919FE0BEE3898564710C51C2B96E5777886931FDBB5194D59E8FA7344F9EF453417536ABB4F32D121EF24F0C118DA0241C1AC90EB39
el numero 76918053057335827735313129613506040736903570810037520026413557868566340917103250649313449229042984510134025751933406259972498634964050
de longitud 134 necesita 56 bytes
Representacion Hexadecimal: 1B1760D9168AF616B7BE1518DAA50ACB6551CC30B92EC6BD98F302240B1D15D603BAC45CBFF789DECB645979AAEAF1E9228372C37D39FC52
el numero 990650373550958716191176265710072063867297281712399448254101662081042804682431016061419404242480156766267423189349887867627041296543677
de longitud 135 necesita 57 bytes
Representacion Hexadecimal: 015CEACA4AAFB5F72E49ED713CFFB16942270A75CD40A3D4B584530E6B24C8BA7940125FA3C14C33E9594E06A1AD5C4CA4CDA93E7BEA9CEFBD
el numero 0505075077326485437615669560261581954749841439467429705300404500721382914519396632306172737406657329353677811076501106797220058836196334
de longitud 136 necesita 56 bytes
Representacion Hexadecimal: B1E480792C242C717E0A34BF331F57BDB45BEC6E0E311527A1BB2570EFF49F4B4530E720F37B3F0D3C2E090681DB8CB8FD0C74DF71475BEE
el numero 16175346817228990600828030910948344125198477150847171608749781080960674302064428768543364109655067507020283916496440066202824070934301600
de longitud 137 necesita 57 bytes
Representacion Hexadecimal: 16411F323F32304035ACDB9EDFE5A477C67D796B35EF6714497C85CA8EAE6CB9C6FB0C0F882E8192AA3339EE40172F2C2EF882831596B80BA0
el numero 820023125180614789802265805351311300398536170722466148813945849106501963067479955070164506867518492175962986416835566113807294304223740660
de longitud 138 necesita 58 bytes
Representacion Hexadecimal: 0468347EB034C4F4E37D4E5CE6F0FCD2DA17407B575DA67096E68DB64C18E319AB59903B1B33F380972B858D4DBAC04D812155CB62773457C2F4
el numero 3463905486041663629284599431528204185594456987997644710216268537928126713235026744328593797699130089852466385336355910303954429913435490401
de longitud 139 necesita 58 bytes
Representacion Hexadecimal: 129DB6C8E0A22AE23F9F44E36D0A35778CCF42F4A86ED484BDCF8A76497EDCB99D98906EB66F5EE477A5B69FA15DCD219761403CE3A890704861
el numero 45359688463372058977628757085784522257835944288532699110375094814881643155184477023078664101775758140539889966609992811216184417884089087023
de longitud 140 necesita 58 bytes
Representacion Hexadecimal: F3C6D02B255762772839ECDB6B97EBDBC20B10D6DF4F31B409FB0160E2DE66562C49770E4B91D9C2068819ED416C8237A05C97A0968F709BF42F
el numero 028895026917618395824920988577867082165080670843521868541175412181875427350127574426457897935602372251121726425667447623678496001138491899753
de longitud 141 necesita 58 bytes
Representacion Hexadecimal: 9B4A62B6F2C8E99864EDD3B6AE1C0CD7733E8822A84A2CB17F7D2F70A920F9BDE3351C0AB173CB9AB4ED2BC046EBE89D783A3C5592AB4537BF69
el numero 9970655643122626998008574202695631494599421807867233020044928015556971236169275369637714486726053879198853997420106057888130898383780501513139
de longitud 142 necesita 59 bytes
Representacion Hexadecimal: D1514DAF61D7BF68ECA2C76EEA5ECCD98A603E43B73ABB48BD78EFC35D13F519B2848B7295BDEC10B1C8882914EA118164AE67D656C095018BE3B3
el numero 29880124233097930760342085611531049963280361287671736225824508385885501750884596201043656516551470585169298341898547195798702296787904981508506
de longitud 143 necesita 60 bytes
Representacion Hexadecimal: 027348C734453480B79B8E1009F2E9C0C67DF59B5C3CFB4F902E9BA26289AE25F17F218E7D7EF65A65C60EC39223DBFD0F08647F82B00CC3C806219A
el numero 143794496309308681436126429947905908777316079418875519252818589403209737983033060488282817855937231812119057180835441619089184977758280096689841
de longitud 144 necesita 60 bytes
Representacion Hexadecimal: 0BCABAE39092B062EE2A95C14EB3BDAF5BDE8AFC05FB6DE7D8DFCB7BD9A98A60F2A9E52318A73DB87B1D42E2005C9270E49D46A0B5110E8B19DC2EB1
el numero 4303127476063017282622847581328577491450069002789208999015503640656269058918177584704585255127593094213007549411671968298621918393609240714718563
de longitud 145 necesita 61 bytes
Representacion Hexadecimal: 0160E11DCEB23FDBDAEC628E1B56CCD878F030FC3F1E4400065754B334184E59CC4C4F782CE0AFED4DBD4EB2ED5F99160BB1034120ACE4368291D4AD63
el numero 35045171522114436804891950132795309064877778393431959634331749753714009236649409738023062334326982468393482252713656244352561578628874018759274752
de longitud 146 necesita 61 bytes
Representacion Hexadecimal: 0B39E4005CFAD6B922C482E22E620570AE5366D7E13826EAB93290E582DF79946C10ED10053E80EC22518F8E46D2073D30EA343B619E97B27BDD067100
el numero 879627767345420534685724862738312608401799767397342387787173250367734413639018863887596912305846088981109048834772254488039321407051620562477374295
de longitud 147 necesita 62 bytes
Representacion Hexadecimal: 0119C628E17120BF96722C00FCEACFA61CF004512DDC80B28DB02028027C02C29DED184B3F6339BB4C05EC85DD48C21343B1255EAE4FA406A45D572DDB57
el numero 6306952020110958322292363282190256517211934890121246395016073684494130090084069918093337070059120233720290859941284092062144569587118146238241642318
de longitud 148 necesita 62 bytes
Representacion Hexadecimal: 07E453A425FAF5D45B16223F9F891E1CFAEBF1B0043921980BB83A158D99141853A776172BF26540ED6F7CFBE5BD2E3A4DC304E030BBAE62F11F15DD174E
el numero 24280800277405627642918122757947583238685727980021488115267921007675161224997208071952446441241743125041999873254656509954703638229149365239018768441
de longitud 149 necesita 62 bytes
Representacion Hexadecimal: 1E61F2E22CF40A8134DD830DAFE86210F4EDD87897A00D17416A2EF49B8412B3DE8A1402B14815C682AB6D126B8880CF1BEC9A489F070F5349013BB54839
el numero 601811661225973490776488259255404368881626014475901071602853105449551443393252069967976628022505002963939744221093083227676421506641289306379838635152
de longitud 150 necesita 63 bytes
Representacion Hexadecimal: 02F10C5003242E56D13074A2DC6E2F5656BE10EF93795EB5110F47098AF8339A907B0D2260250408A8BE2DE88F79BFF65B408F5616E1FD321ED771F02D3C90
el numero 1803453696049076905847221303056771265723969265416928814529813508330076122333009953711013562017233164975335174016400827776573484201261877528013272025046
de longitud 151 necesita 63 bytes
Representacion Hexadecimal: 08D0AA43E7595266C25D0B2461B5D54A2C1B06E4AF878483688221E3D22402532DC7C915C2488DFD5DD7466F2011292EAD741CF110557205B35A91481C87D6
el numero 14951516832088136958964627054836102869440359462395372443381025570312018067835804462961169976055342919267878133577648346575775985540457453636407455297017
de longitud 152 necesita 63 bytes
Representacion Hexadecimal: 4914DCA7CEC9A68BC0E930498592155BAA88120C125FD6181A5BF7AB4A60E0CBE5DC1D3FEFA99C5F0A432ED872F326E523C698A30383B556A4465CB792ADF9
el numero 938591492656353155240262804094127344225282815851256310932089937530024411092873326496859783057878525576443023386682082790499202651275198766008341155963968
de longitud 153 necesita 64 bytes
Representacion Hexadecimal: 11EBBD59B77FC466AD6D549BAD2B05DB999915BD5AE3F343EB46857586F62C16FDABA2739B54A0DF19AA02AA2CE90BD71A9B0E331A8AC902C3A9EFF6F5CE6440
el numero 1210139123387774077710451188051151170495589897165688103239745663052436314417169765657598114353914978808327148907861494822699349113252808601449624382429061
de longitud 154 necesita 64 bytes
Representacion Hexadecimal: 171B096D14A896ED107416211F0EB4EEBCAB5E9C7D575CD472D2FBCF9ACDBB8ACA56C10CCC466C14E6BFDB4BFEE1BA3856E51EA33EDF0321014EDF13BDBB5785
el numero 26265998254619245027344987272498758070807803963474597636954199416280305410422111624304827394264068639695091403150300622540621330111698734350901008173280664
de longitud 155 necesita 65 bytes
Representacion Hexadecimal: 01F581866D639DA092B497C45DF52B92B29F6F4C0F73A84E13ABBBB20441323D335C166BFE15DF6B3A39DF23DCE7A6A274137FA8ECAE5C7C260A5DEDF7A776AD98
el numero 574112355883972769021786912892582449109113904342098515932776271725775338345563753966063763219385881627367087718160847008172355850207674477438327775545456579
de longitud 156 necesita 65 bytes
Representacion Hexadecimal: 2AD1BABD882AD9D6D431BB3B9BEBA6AEC112AF51C9EEA7F95C1B3BEC9657A356E19E869F87EC7DE841FF0BF5C4BF0A553DBE1B7BF8F5336A5364B62F6B6226F7C3
el numero 3132053536104327435055540037479869797939661538144197399703148559258385065405571077163155826931751909298562691824717848337562989148866494947890542951754266649
de longitud 157 necesita 65 bytes
Representacion Hexadecimal: E99966C8A6DE54D47A1443EFD5FA74D7A276D78D590C6FBA979C092F1475CC84622D437EB6DEABBF479F33D8A265EF17D755F218975C5CAB563951E38E7A367819
el numero 48584992462389457051297228363530744201040283819627078659475542070444104384954989979233259293358220421374690915562487904332154488868808352661575626496124820824
de longitud 158 necesita 66 bytes
Representacion Hexadecimal: 0E27A2604F57BADF33E7E19920046EFB8B5BC84DEE887EC9A862FE76969DEAB55353F5285A2B88A1F30423CEB18CCBBB2405FEFFBCB0DE901DF16EF65705B2069D58
el numero 193736435568289232487646483210385957647500102682464989748404708518807984879779651237636395247945391510488337589157380489650209362044487400303454982271368563951
de longitud 159 necesita 66 bytes
Representacion Hexadecimal: 387186031FB04E450D9598BAAAB6D8DFC207F8CFCA37256CEF476C58D071D1EDA9DA908EF0F571440841A0685F0E671FDF084E3CB2869E6892BD1B0D7BD3B8620CEF
el numero 2038515687587574128494620659904914163489175224913421468346046885779250361391339132610024547884400354769926165296350638836146891421379550977184395890751775343858
de longitud 160 necesita 67 bytes
Representacion Hexadecimal: 0251E7722285660429248F3BFB9917B5C6AA430964AF615C5992E60B7895A3652E61FBC6A102D909E3276D959292404EB70C2BD892670D0CC455260E8B65AE1BEE84F2
el numero 55615613056387188889887207175862024771670216204108609497426546964819734679439360933798473104271662589425584299452654250077309479071007793307077599898623106561392
de longitud 161 necesita 67 bytes
Representacion Hexadecimal: 3F4B21EBE6D956D9AD140CD59698AA9A1BE0EF86E0F3AF7D4126D1DC26D8CF0BE71EA1144FEFE57BBA816412ECD342883B2FF3EDC83C0DCB3B1C421604A931AF773570
el numero 665921411600388792697597969691550085612319795170291457178341992071900209265845902688290447212848651904561704812402461643546374113186105549430106189864880269333171
de longitud 162 necesita 68 bytes
Representacion Hexadecimal: 02F5DA7FE1119FD3BC5DF96E95EC2E80B1E376C8AE3BBC3F2DA9D2B2AE1764DAA71A6F28FF38BBDC03C97B6EA2C25CE8EC6AB85076090B9795AF092831F0DA6B74EE92B3
el numero 3137123889713254347423474973284947515173672419130687802520730656907697871901709900892814662713934885147603447408171641364841434257975077945247641593237766593472143
de longitud 163 necesita 68 bytes
Representacion Hexadecimal: 0DF2362CDACD59C1B4FA96302114E6B611C6661260570E4243CA21CDBD3E4E0E8918DFAA38ECCF9E15A96DE4C1ADB88C11C9FC4C4EB89019C23A37393291EFAFCFEA668F
el numero 99864964665844489014398660427769336682491869256758136478730681378064670114098289538177153875283410901026480218537929513367881606001796523989823835785435467267952504
de longitud 164 necesita 69 bytes
Representacion Hexadecimal: 01BBF39217DF125D307E5A0B454AC1290AA7E21C854D633CEC098791BE90C913056F535C7D174E71D23573BF8B1F50D0BC4B3707C3BB3A4CC8310F130F8AFB80BD090BCF78
el numero 043757283404122712174064833631932101370216251659734673275884483234739618974293380487786765862941796254799587764591973479247791423953104825677085799927539817720608581
de longitud 165 necesita 68 bytes
Representacion Hexadecimal: C28615BAFF1395FE92266AC4D0C95C04FD38624B0043774513BC4C38D02E77C5FA8712329E653AB76438EC96FA135D5DB9849BD326D5C53A63E881F8F4096EFD8F807745
el numero 7484191812529188982425817457184969868481088018562089687220808147481923377473944369831289349780555277323829751321891727294129232102991046750299974095862434894566500307
de longitud 166 necesita 69 bytes
Representacion Hexadecimal: 81F71B0D1303F91B892F75592C68AB6CDD4E7E12A2E3862B5BE19FE580A8A4EBCCA5871B052C476C249D753F93971582E1201507FF19D0FFE9DB5682ED8B688F9FFA65A7D3
el numero 52225677522454219083645609403495499927127873528424700131276177601279316845824438355502709009316771661703840803195801331924766603397618515600254409769109646398206115139
de longitud 167 necesita 70 bytes
Representacion Hexadecimal: 038AEA29CF7279596E92911C4184002D9C9E85A87801F8F99306EE9ABEE71FFA6CD7F9BA7AA43A13B96390E126143DF5927DFB1F9B8EA44AD4DEDB029DC3583A67D436FDFD43
el numero 728483705267895568974358275451061968866304106279214862509402649299401015450247674234110208016431626347045670358743253309501144719045229358570966055975798123547381647354
de longitud 168 necesita 70 bytes
Representacion Hexadecimal: 316A570F3A47EBE027A1A8A42D1AFA7641725BE5C8CFA0B3223112D24E8A4B7666D228D6D8B359925E4B11EF0D6019A6C572358BAB20A3DB9219159D9CBA800AEA0230CAC7FA
el numero 9755663430229459879746453388575077637472593054153089383175836212962354747265848420517003222801246587816675397440695041296269779896458612188391822859664316611682433750698
de longitud 169 necesita 71 bytes
Representacion Hexadecimal: 0295C20C7E3EF711AACE0323D67F7DF67486CB48BB698633F097216A83190DA41020F096E8E7DF3B7BD29339F0D88252419AF59C99B2EB008176869DF6371A7103482A4B73D6AA
el numero 82167942353008508622522760576774701819505252134141540416517935663195653299982840386662339778873295791536265267486397948680408360761352549863454455820925596336292353477635
de longitud 170 necesita 71 bytes
Representacion Hexadecimal: 15C5B73195ACF329F5930CE17DF8ED1FF787824D7510531EBAC49FA643DC247135F57D2C40ADD8B7467A5FE85FAC19C3B579ED9A76C3D265BA1309606055456D3BC5A00C3B0C03
el numero 407252752124781972612113577212903591928314667566374498635592988092533922083006836488676104547319855691624436681564365279288070249381823411121454333497099111226636806325771
de longitud 171 necesita 71 bytes
Representacion Hexadecimal: 6BE943541310AD47BF89AE345AE2BD4AFA237BAEA7B397EF75E747AA98ABA29DE61DC5B3D77626DCF6534A7F89CF70A8BD44E6D19F899BEF8C629072ACDECAC1FE637C7DB3060B
el numero 9221321412993389469414040020146209457939921976899311936782773268749062785757171483385853665525941918052043147574427721559883695530074288849396166217948304154585790233938455
de longitud 172 necesita 72 bytes
Representacion Hexadecimal: 098B67DDE9171E706C9309C686113D645511B0F884EA55CF91859D0062ABA0201C19AA5E6DABC475E5F4CBAA28C89AE668A83119321440CF9052DC6F914CB07948F6D37922778A17
el numero 63173346553835066761608002082553903479716804969591577839417893959942670282343517896423353057274044060132050139413102586156682375215980803060984973449981170195996806435638288
de longitud 173 necesita 72 bytes
Representacion Hexadecimal: 4163431F659468CE9AFB8B13DA416119C8A5447712C10F5D874FF85AB06BE07D60DD12A27F9F232246EF61A8FE75D97DB8DFEBF296FE61597F1D7C6D2A576E51189D20CD053D0C10
el numero 468618591022389116571966237958039761284491900604902855321910709575092503315084301613844931588037440946722897509159725009133401939631960782657928089598627603260905291799563254
de longitud 174 necesita 73 bytes
Representacion Hexadecimal: 01E50B81122CC4E90E23D48DCFF45353005158F228942C6E93E4FBF78FA5D90433A9E964BC1552E66997E11C5E53C2ED3495790661C8BD649B6FFF17C62D96300A05395DBB4E278BF6
el numero 9441320238861761908057277988677146106740526553785548772245100872241792439194959532438994144195357000935354718692622794053577549101475272210879580444877764059239441230798268088
de longitud 175 necesita 73 bytes
Representacion Hexadecimal: 262C43963A090BBF62C64FDBCA1CEA25625A7E1EECD818BCB190EC0989AAA10F4AC96F80DE8760C21EF60B268746DC5122F484363C36B9DAE35D4C60F1C5DEC93079190155C8DC26B8
el numero 66201816876434779029386998261048259910846047704175500653092660786873279684404345994970750469392290764201118564228964828988124849300991926497692881555773236306710384054174000347
de longitud 176 necesita 74 bytes
Representacion Hexadecimal: 010BAA5E8D7EA08915E6602CAF9720FFC7F9117CE56EA540F4CBFD4B3512339FA8222E1513AE58CFC2A8B44C8781185DD90BB647F1FF919221BA942F2A210DC85859AF46D480412CA4DB
el numero 956632988234320416875248664405274059320084772424201469950761964865225034927635952570803101805928706790733892632114053450590321833799233180224468304304025571370479900136389897919
de longitud 177 necesita 74 bytes
Representacion Hexadecimal: 0F1BD58ED9E265C84A06A5184776A6BD515ED92C1DB34FBBC50EDCC21A3475B543555DAB3A46178F67B9A6EEA51EAC63C6F1D2F8CFA690B879FB5900695AB6D268B5CF1DBE9D5B966EBF
el numero 2236265026573651526785692097182192720632073965833191789015579655489439796513664545751302934929028354732557179824318037601761073452185462971953537580667638429729678829489287632833
de longitud 178 necesita 74 bytes
Representacion Hexadecimal: 23519C27B7A67E788BC698B8E8C90D38ECE1FBB9E41DF5C5D91AC60018FF4DD03B25CB1C37BFEF7A3A548B6B185198107EFCBDE114DA26E31C267392A68B5A1B9823D2BD51AB5FF097C1
el numero 15218051265630789217677394113732195553301837663444314400829206179316637312046908297600406772682893185645941591279286660771761768517021575338269273971018578783427011205713676467224
de longitud 179 necesita 74 bytes
Representacion Hexadecimal: F0593D0FAF619B7F144A450D4C059CB62778831943BC650E1995A3D8F94DD5966F86D9220A4FF8A986DEFADAE1D2169B8E0FAFFDFDC9619C1FE6DB3ACFAC1E8D393C5220D42E384FFC18
el numero 890800939877613399426802627544440152583936725904701751349911639286606905278881966637067285976495642616100730549215739027510337946231116787171666277253663853739893575136156321459878
de longitud 180 necesita 75 bytes
Representacion Hexadecimal: 36F4FFBE92116545F5A784A39CC5063315FCFC6DC75B5E761EED964E5BE0C0D25C93A9B073B013BA0836B6839463962E0B5B776F651A956B41681EA6407E8E18CE15032508D52393BA2EA6
el numero 1576322203744466317074031392926648148691410062250762085972807664361608989387777771633295886246710327949155240096042031291739034117818853498027404748956569346747585187120004160684604
de longitud 181 necesita 75 bytes
Representacion Hexadecimal: 613FE1EA187CFF2499444DBB3A4A29043A49CB6DB5C9A1C211D94DDD2C46961B7A65F13BCBA4F18B4498CD123A3B131C0B47F3BFB85CB6FC1C4A36BAF3F2C2125B47F7A0A29EDB64C2023C
el numero 10204852158926987319251394064954577851199332496491109589853111273799641277386810367032007803587264453383476520524900230325216158699429394957815746084647924867353679179603664793174097
de longitud 182 necesita 76 bytes
Representacion Hexadecimal: 027593DF2AEE54B380787DFD2B20B87CB05AA0F970570FE236FD23ADE0BE7A064EC7AE8A3AF1998FA6B57BBE7A2B5A46989F3D6E5F202C93D44D5286F91CA83DF225C0FE9A35D1FB38370051
el numero 929834186817372195789477260843510086041236830759673450661206588944231279371095525071759510135805673771703662146861485857220595817752028755420541815437452233218207464136879410992633250
de longitud 183 necesita 76 bytes
Representacion Hexadecimal: E015247977183BEB898C709BCEC51A390339DFE9896B4A92F05E39F4113B0DA3B8CA3A86B66EAAB0792895F545DE0A0C3E5EB8AEBBD97E567965034F2FB9ADD9DBEBC37C6303C79D07E7D5A2
el numero 6982488007321454439233775558504173972064990411999311751206351429170256507494249861406216816432164775234512828825263899437577324484567760406339756145238954652930331909437765844041903471
de longitud 184 necesita 77 bytes
Representacion Hexadecimal: 0692B9417F7678809C585CD037B908CD1286BD8E91AB8F845E7A432205606D823CB71E32E5CF89DE2608322C2229E15BA2F46805F46A90E0681AE6323B497F135584B98C6E26E73327B5DEAD6F
el numero 11654628873036855516664277473957806839094762571250128885077334912087000034259518694421233460167176969004738717139274884685983153359759328390986552361070058778710893206059549206082776471
de longitud 185 necesita 77 bytes
Representacion Hexadecimal: 0AF8AC12F33008D7FB53E2D50D0C5A6D43BE6845ED952749B0DA407708B1ADD7CEE108122248682E52297B37172A926995C0688BE9EFB082E42B58C5D133EC1C55AC3216AFEAB658FE57D06D97
el numero 733184191284093695840872393831791454544550446187429536446501115933934306089298551630470248295336066039768318195193110268695224044203799089219781389221658180523304006828970974073859796930
de longitud 186 necesita 78 bytes
Representacion Hexadecimal: 02B23383C5B48CA3A035426B5F08B1B9E0583AD394462D4DEBFFB64D325EC7E7079EC146B053A65F31B878901654385D4CF8BF4BBEF57A2B40DB07C3BCB1A81340D1C4C7218B13D06BD15DB6EFC2
el numero 0579191184502494228336865731319719585607245675208368906911392979898493648233375883063585393295361660890118494036463035846599185884244881524731272423653384464872333742327709291460091285467
de longitud 187 necesita 78 bytes
Representacion Hexadecimal: 02213C6F22A70114F516FC79C61513BEA59267B288F31F0ACD6B746E4EF2D91EE00520588BE8124152C8DDFF6D05587AF4F29B233D70F982B24682AF2398E739DBB0F8A3C708BFC7E545F2718FDB
el numero 50667000027950586705348122416574976426367543746854615482295755497166952025818979255608891616905744916847274859700572799093132676567356122553342089999714053635014942371694044726814620282816
de longitud 188 necesita 78 bytes
Representacion Hexadecimal: BA50A4FCBC96F63E746DF2068C4CA5136F1E9B21BCD15611FFEA011E490C7A849885B47AD721BEB2AC07863EAEACE91DB03FF0C34D093326B25ABE58655570FD8FE47A1C44632EDD4E9052586FC0
el numero 962918066837560817446629501231602927170322008829780636331118265769885374360002344762956380252482022739588976127510696798186751344515016099959047415588695925289404971186098846799886484968210
de longitud 189 necesita 79 bytes
Representacion Hexadecimal: 0DD4E2F1C619C0A313583F014930A1609F1E30EEC578B9013F25577EEF955417D276A9C3D244C8E8A0480186A50E39A36DAFE6E9184D1CBA38B4641A1FBD77CE3F010668A22087733D53007D4F1312
el numero 7606223660759904362694061154703514977500830559772776327944340720430725262903364859670566534197553469583024421888300558391436006184649228148250602735947136183373721643415653967042642635391126
de longitud 190 necesita 79 bytes
Representacion Hexadecimal: 6D41F465D91C41B6E991F5B830BA2CF1546D4D83DF6DFCB71842D0E6AF9DB6A56819B3050C5CDB1CD16B29645A91D29EF583D532E74617BE9A6E3EF2D1B53C550A962CFE844395DF725308D7640096
el numero 97098489746676328679960841518746643859142060022509113618706971555582715259459507445037751199100778180968866092589810159638674669721702810011743597240924024452774443828069982981593465036258453
de longitud 191 necesita 80 bytes
Representacion Hexadecimal: 0572BF05AB334D6121BECADE5E6FFBB083D3AF5D6CB496B116A0DBCDECA9C8E0953398CE3234CADEF74F641A887C5774D8D66D6A2CEA956E2223A1B07BA69904F09FEEC6952057E8B88FC6E7140CBC95
el numero 352487265103728660800220548361354389703248570367090338320022451086971894039918585596410484986504930211008270470135775428998955024120357052915942568328683625141807799216499601982261166913977060
de longitud 192 necesita 80 bytes
Representacion Hexadecimal: 13C736589CED1D9543AFE9995958E2346F81EC6140E5D3DFA6B680ED411B92D0616DBBE7EF41186438340B6324FE10CBEAAC51F5F63B53A08461C0503D04C751F74E9730A50445C4F104DBE256357AE4
el numero 5410953246001851022702854833742871831551244157179518972560823682471319993871962400004750578707564005323449787493349772308216007135716874175877666241292552191203508553936183647761025331880306194
de longitud 193 necesita 81 bytes
Representacion Hexadecimal: 012F9C3D92D447852ADB18483090DE9F86C49D00116C3757072EA9865D2B66EC5196313D7F8766F7AA4F756CA2A3106095913CA6EDC2A930BB07E4534083FF950E27ACF869085FF7891837241ADDE8A612
el numero 92288995921016356489764072118524793355830567596183692829637252415925119483567685372346132342593870447614208331748673724934250972331889023548267400466591497894874936353787468393211070640774155381
de longitud 194 necesita 81 bytes
Representacion Hexadecimal: 143A5D72C00DA2D3A12EE182EBECBB623F80FCD184E6DA949251F40C26D9BEF041B69F548A7C014753B92DCF3011A212014AEB2956CCAD3ADA8266AF02A535D5D360D885A6DFE6530E34E68EA7F5DF8C75
el numero 666223039300817701183248482791674826967860232226059523394806052771522744357867402923582957069366870740813262871140350982088660971178530512204648788408499377902059714895176626845961309478942138799
de longitud 195 necesita 81 bytes
Representacion Hexadecimal: 9205FCCBB3BA017F01B0F7A2032404CB3CD9CB36EDD8B0F5CB0CFE8D7C762513555CC637D5C2319F202A5963D4B16CB71BAC6EF2619E0FB722C78855785D7FE3CF967F95DB86B853E4FDF3428CEBE3E1AF
el numero 0268069098288053428141262128452631287059874768979245853115164303366287237784656341842151367191603425717955703104598514905500250840293753425484566527032827867260739733705007889924585412824255336584
de longitud 196 necesita 81 bytes
Representacion Hexadecimal: 3AC171555B3BC008B734BC946396A2401C931539F738A846BF0B206D0FF3FB8A199E6D8AD21AC6CE2222FCF87009D9E6419BD4CE38D92773B779CF9686F93A8672BE18602247F52FBC8E57860082429088
el numero 46675235364426238860442958157735415161937274587667939300106805651691508062397624832217121376793998051827442212791032135149433126602421915849709266846548165695226199585354000816173324761999152656874
de longitud 197 necesita 82 bytes
Representacion Hexadecimal: 27F6525C7F3938C6DB3BA3FA35D8B218340ECBA8A0BBAFADCB92D370A58528351B82FD691C30B7939D7628D8F504DC83C7175F9B8B1FBCBED30ED58F979664FF5059A9D8532FEA2AB9231D96A25A189E31EA
el numero 376688714300366901896837708590508220948047565752041789331880930418887546731431762067766663550312817783337436473283466950852186939242092850735269953577998811749327673166452068539846047251055073342411
de longitud 198 necesita 83 bytes
Representacion Hexadecimal: 014282FC0C9462C1F8681C68F396CAA6E62FB2769B4D3223C1E6F2A71DF3EA8E8F16099856B687E29B5C4A04D8E1AD019B2776C2ADF7E662DF2657EE9250B995FF19E5DA88D526A0DC3727CED847AC5C40B3CB
el numero 9520053310329229285225450236586294786934539102867166542953092020822337743361264728952538566343918949539426288815451556017739784800599667091393326967621824168558684791240745824211713803370604505399005
de longitud 199 necesita 83 bytes
Representacion Hexadecimal: 1FD6D62F533BE763073CA84AAD3026252032C863B070669D4611F25A0E0A8426EF0BD5A97E9BC3065139C7F84A8C308E3274DFFE10E87C6BF98A547914EABF065BFAD0C4D95F45C5988E02DC9A892203ECFEDD


Algunas representaciones pueden comprobarlas en wolframalpha

https://www.wolframalpha.com/input/?i=0x1FD6D62F533BE763073CA84AAD3026252032C863B070669D4611F25A0E0A8426EF0BD5A97E9BC3065139C7F84A8C308E3274DFFE10E87C6BF98A547914EABF065BFAD0C4D95F45C5988E02DC9A892203ECFEDD
#41
Programación C/C++ / Simulacion de Comunicacion.
17 Noviembre 2018, 02:46 AM
El dia de hoy me pidieron ayuda con un trabajo escolar mega-urgente para ayer... como es costumbre  :silbar:

El programa trata de una simulación de comunicación, supuestamente solo les faltaba la parte que simula RUIDO en el canal de comunicación. Sin embargo realmente les faltaba todo.  ;-)

Se me hizo interesante ya que el código solicitado tenia su grado de Dificultad o por lo menos no es un trabajo que le puedan que dejar a alguien que apenas esta aprendiendo a programar.

Hize la parte del RUIDO prescindiendo de todo lo demas ya que se me hacia bastante didáctico.

El codigo lo hize de la forma mas simple y INEFICIENTE, pero trate de que fuera lo mas entendible posible, como hacerlo paso a paso.


#include<string.h> //para memset()
#include<stdio.h> //printf
#include<time.h> //para time auxilizar de rand()
#include<stdlib.h> //Para rand() y srand()

int noise(char *data_stream,int len_data,unsigned char cuantos, unsigned char valor);

int main() {
srand(time(NULL));
char data[50] = {0};
memset(data,'A',50); //Mensajes con puras AAAAAA....
printf("Mensaje antes del ruido:\n%s\n",data);
noise(data,50,10,1); //10 bits con ruido por cada 100 con valor a 1
printf("Mensaje despues del ruido:\n%s\n",data);
}

int noise(char *data_stream,int len_data,unsigned char cuantos, unsigned char valor) {
printf("\nModulo Noise\n");
/*
Recorremos bit a bit y calcular si va a ser o no modificado en base a su probabilidad.
Este método es en base a fuerza bruta y es ineficiente, deben de existir mejores, mas eficiente y de forma matemática, pero dado que se quiere un programa entendible se va a realizar de esta forma.
*/
int i = 0;
int index;
int bit;
int r;
int cantidad_bits = len_data * 8;
while(i < cantidad_bits) {
r = rand() % 100; //Calculamos un numero  "r" aleatorio desde 0 a 99
if(r < cuantos) { //Si el numero "r" es menor que "cuantos" significa que se saco la lotería y a ser sometido a un poco de ruido
index = (int) (i / 8); ////calculamos el index del byte en el que estamos dado el bit
//printf("El byte en el index %i va a ser editado\n",index); //Esta función puede ser descomentada para depurar y entender como funciona esta funcion
bit = i % 8; // Aqui calculamos el bit que tiene que ser modificado en el byte marcado por el index previamente calculado
if(valor) { //Si valor es 1, establecemos el bit en la posición "bit" a 1 del Byte dado por el index de la data
data_stream[index] |= 1 << bit;
}
else { // Si es 0, hacemos el proceso opuesto y lo seteamos en 0 en bit en la posición "bit" del index de la data
data_stream[index] &= ~(1 << bit);
}
}
i++;
}
}


El código trabaja directo sobre un apuntador que contiene los datos, pero podría trabajar byte por byte con sus respectivos cambios.

El programa funciona bien.



Parte de lo que me pedían era lo que esta en la siguiente imagen, pero realmente les faltaba todo....

#42
Seguridad / Investigando un intento de Extorción
15 Noviembre 2018, 00:41 AM
Recientemente revisando el SPAM encontre un correo interesante.  :¬¬ No me juzguen el SPAM a veces tiene cosas interesantes.

Basicamente el correo indicaba que Yo habia sido hackeado, obviamente un intento de estafa, decia tener datos privados de navegacion y fotos desde la webcam del sistema, adicionalmente un supuesto virus/troyano/bomba logica que automaticamente estallaria en 2 dias apartir del momento en el que abri el correo. Idicaba que queria recibir 848 Dolares en Bitcoin y dejaba una direccion.

1PcFYw7PQKUnj6RxqVwZ4TFuwWUPTyECKQ

Lo que me sorprendió al investigar un poco mas es que la cuenta, si a recibido depósitos de Bitcoin en días recientes.

https://www.blockchain.com/btc/address/1PcFYw7PQKUnj6RxqVwZ4TFuwWUPTyECKQ

No se como hay gente que si cae en estas estafas

Actualmente la cuenta tiene un total de

0.36282302 BTC

Pero a recibido mas, ya que a hecho retiros parciales, movimientos totales por:

1.67353487 BTC

Otra cuenta de Bitcoin usando el mismo esquema, posiblemente la misma persona

https://www.blockchain.com/btc/address/18vh8n7xX5TRPMJyAHu5V4s384FuXreK4h

Sin movimientos a la fecha


Dejo aqui los detalles del correo original:


Received: from [115.21.112.165] ([115.21.112.165])
       by mx.google.com with ESMTP id i12-v6si5818563plt.9.2018.11.08.17.58.30
Subject: Security Alert. You account has been hacked.
Date: 9 Nov 2018 18:33:23 +0800
MIME-Version: 1.0
Content-Type: text/plain; charset="iso-8859-1"
Content-Transfer-Encoding: 7bit
X-Mailer: Microsoft Outlook 15.0
Content-Language: en-us



Hello!

I'm a programmer who cracked your email account and device about half year ago.
You entered a password on one of the insecure site you visited, and I catched it.

Of course you can will change your password, or already made it.
But it doesn't matter, my rat software update it every time.

Please don't try to contact me or find me, it is impossible, since I sent you an email from your email account.

Through your e-mail, I uploaded malicious code to your Operation System.
I saved all of your contacts with friends, colleagues, relatives and a complete history of visits to the Internet resources.
Also I installed a rat software on your device and long tome spying for you.

You are not my only victim, I usually lock devices and ask for a ransom.
But I was struck by the sites of intimate content that you very often visit.

I am in shock of your reach fantasies! Wow! I've never seen anything like this!
I did not even know that SUCH content could be so exciting!

So, when you had fun on intime sites (you know what I mean!)
I made screenshot with using my program from your camera of yours device.
After that, I jointed them to the content of the currently viewed site.

Will be funny when I send these photos to your contacts! And if your relatives see it?
BUT I'm sure you don't want it. I definitely would not want to ...

I will not do this if you pay me a little amount.
I think $848 is a nice price for it!

I accept only Bitcoins.
My BTC wallet: 1PcFYw7PQKUnj6RxqVwZ4TFuwWUPTyECKQ

If you have difficulty with this - Ask Google "how to make a payment on a bitcoin wallet". It's easy.
After receiving the above amount, all your data will be immediately removed automatically.
My virus will also will be destroy itself from your operating system.

My Trojan have auto alert, after this email is looked, I will be know it!

You have 2 days (48 hours) for make a payment.
If this does not happen - all your contacts will get crazy shots with your dirty life!
And so that you do not obstruct me, your device will be locked (also after 48 hours)

Do not take this frivolously! This is the last warning!
Various security services or antiviruses won't help you for sure (I have already collected all your data).

Here are the recommendations of a professional:
Antiviruses do not help against modern malicious code. Just do not enter your passwords on unsafe sites!

I hope you will be prudent.
Bye.


#43
Seguridad / atube catcher? Virus
10 Noviembre 2018, 01:12 AM
Pues nada, estoy tratando de Bajar e instalar atube cacher desde su pagina de interenet.



Y me sale la siguiente adverntencia.



Alguien sabe si tiene virus o la pagina a sido comprometida, al estilo de ccleaner?

Si es asi, alguna otra opcion via softwa para bajar los videos de youtube, a cada rato cambian la pagina, antes tenia un JS que me devolvia la URLs para la descarga, pero ya me canse de depurar la pagina de youtube.

Saludos
#44
Desarrollo Web / Efectos sobre Canvas HTML5
6 Noviembre 2018, 16:18 PM
Muy buen dia compañeros.

Estoy tratando de crear un tipo de efectos sobre un Canvas de HTML5.

El canavas actualmente tiene una imagen creada mediante javascript consiste en las clasicas Barras de Colores que salian en la televisión.




Se crearon con el siguiente codigo.
Código (javascript) [Seleccionar]

var canvas = document.getElementById("bars");
var ctx = canvas.getContext("2d");
var colores = ["white", "yellow","cyan", "lime","magenta","red","blue"];
var colores2 =["blue","black","magenta","black","cyan","black","white"];

var i;
i = 0;
while(i < 7) {
ctx.fillStyle = colores[i];
ctx.fillRect(i*182,0,(i+1)*182,537);
i++;
}
i = 0;
while(i < 7) {
ctx.fillStyle = colores2[i];
ctx.fillRect(i*182,537,(i+1)*182,72);
i++;
}
// Create gradient
var grd=ctx.createLinearGradient(0,0,1274,115);
grd.addColorStop(0,"white");
grd.addColorStop(1,"black");

// Fill with gradient
ctx.fillStyle=grd;
ctx.fillRect(0,609,1274,115);


Y queria crear una animación asi tipo distorción.

No se que tipo de operaciones realizar en el canvas, primero pensé en agregarle alguna capa de blur

Pero preguntar aqui por si alguien ya a hecho algo similar en el Canvas HTML

Saludos
#45
Foro Libre / Plan de Ahorro infalible
16 Agosto 2018, 23:44 PM
Plan de Ahorro infalible

Sea la moneda que usen en tu pais y estes donde estes puede ser desde 5 Dolares semanales, 5 Euros, 100 Pesos Mexicanos etc..

El unico punto es que tiene que ser SEMANAL y CONSTANTE

La mayoría de los países, si no es que todos, tiene un sistema de inversion en instrumentos Gubernamentales. En algunos casos esta accesible al publico en general.

Nos vamos a concentrar en instrumentos de inversion de liquides mensual.
Estos instrumentos pagan un %de interés al final del periodo de inversion y esta es la Ganancia

El ahorro es para aprovechar la ventaja del Interés compuesto

1ra Semana ahorramos la cantidad elegida en instrumentos a un mes
2da Semana ahorramos la cantidad elegida en instrumentos a un mes
3ra Semana ahorramos la cantidad elegida en instrumentos a un mes
4ta Semana ahorramos la cantidad elegida en instrumentos a un mes
5ta Semana ahorramos la cantidad elegida MAS la cantidad que ahorramos la primera semana ya que esta ya venció y se reinvierte
6ta Semana ahorramos la cantidad elegida MAS la cantidad que ahorramos la segunda semana ya que esta ya venció y se reinvierte
...

Asi sucecivamente

El patron de ahorro anteriormente descrito nos presenta una Liquides Semanal (Apartir del primer mes) hasta por 1/4 parte del total de tu ahorro cada una de las 4 semanas

Ejemplo para una persona de 20 años en mexico ahorrando 200 Pesos Mexicanos (10 USD) a la semana
- Se considera un aumento de ahorro de +25 pesos semanales año, esto para compensar la inflación y ajustando a los aumentos de sueldo que puede tener la persona año con año. Esto es 200 el semanales el primer año, 225 semanales el segundo año, 250 semanales el tercer año y asi sucesivamente.
- Se considera una taza de interes Fija al 7.75% (Ultima taza registrada en los CETES de vencimiento mensual)
- Se considera que las condiciones macroeconomicas del país no varían mucho a lo largo de los años.

A continuation se deja una tabla con la edad de la persona, el interés generado Semanalmente, la suma del interés en 4 Semanas (Un mes) y la cantidad total ahorrada en el periodo de 4 Semanas




El saldo mostrado es al finalizar el año marcado.