@ -123,180 +123,10 @@ bytes dev::asNibbles(std::string const& _s)
return ret ;
}
#if 0
/* Following code is copyright 2012-2014 Luke Dashjr
*
* This program is free software ; you can redistribute it and / or modify it
* under the terms of the standard MIT license . See COPYING for more details .
*/
# include <cstdbool>
# include <cstddef>
# include <cstdint>
# include <cstring>
static const int8_t b58digits_map [ ] = {
- 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
- 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
- 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
- 1 , 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , - 1 , - 1 , - 1 , - 1 , - 1 , - 1 ,
- 1 , 9 , 10 , 11 , 12 , 13 , 14 , 15 , 16 , - 1 , 17 , 18 , 19 , 20 , 21 , - 1 ,
22 , 23 , 24 , 25 , 26 , 27 , 28 , 29 , 30 , 31 , 32 , - 1 , - 1 , - 1 , - 1 , - 1 ,
- 1 , 33 , 34 , 35 , 36 , 37 , 38 , 39 , 40 , 41 , 42 , 43 , - 1 , 44 , 45 , 46 ,
47 , 48 , 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , 57 , - 1 , - 1 , - 1 , - 1 , - 1 ,
} ;
bool b58tobin ( void * bin , size_t * binszp , const char * b58 , size_t b58sz )
{
size_t binsz = * binszp ;
const unsigned char * b58u = ( void * ) b58 ;
unsigned char * binu = bin ;
size_t outisz = ( binsz + 3 ) / 4 ;
uint32_t outi [ outisz ] ;
uint64_t t ;
uint32_t c ;
size_t i , j ;
uint8_t bytesleft = binsz % 4 ;
uint32_t zeromask = bytesleft ? ( 0xffffffff < < ( bytesleft * 8 ) ) : 0 ;
unsigned zerocount = 0 ;
if ( ! b58sz )
b58sz = strlen ( b58 ) ;
memset ( outi , 0 , outisz * sizeof ( * outi ) ) ;
// Leading zeros, just count
for ( i = 0 ; i < b58sz & & ! b58digits_map [ b58u [ i ] ] ; + + i )
+ + zerocount ;
for ( ; i < b58sz ; + + i )
{
if ( b58u [ i ] & 0x80 )
// High-bit set on invalid digit
return false ;
if ( b58digits_map [ b58u [ i ] ] = = - 1 )
// Invalid base58 digit
return false ;
c = ( unsigned ) b58digits_map [ b58u [ i ] ] ;
for ( j = outisz ; j - - ; )
{
t = ( ( uint64_t ) outi [ j ] ) * 58 + c ;
c = ( t & 0x3f00000000 ) > > 32 ;
outi [ j ] = t & 0xffffffff ;
}
if ( c )
// Output number too big (carry to the next int32)
return false ;
if ( outi [ 0 ] & zeromask )
// Output number too big (last int32 filled too far)
return false ;
}
j = 0 ;
switch ( bytesleft ) {
case 3 :
* ( binu + + ) = ( outi [ 0 ] & 0xff0000 ) > > 16 ;
case 2 :
* ( binu + + ) = ( outi [ 0 ] & 0xff00 ) > > 8 ;
case 1 :
* ( binu + + ) = ( outi [ 0 ] & 0xff ) ;
+ + j ;
default :
break ;
}
for ( ; j < outisz ; + + j )
{
* ( binu + + ) = ( outi [ j ] > > 0x18 ) & 0xff ;
* ( binu + + ) = ( outi [ j ] > > 0x10 ) & 0xff ;
* ( binu + + ) = ( outi [ j ] > > 8 ) & 0xff ;
* ( binu + + ) = ( outi [ j ] > > 0 ) & 0xff ;
}
// Count canonical base58 byte count
binu = bin ;
for ( i = 0 ; i < binsz ; + + i )
{
if ( binu [ i ] )
break ;
- - * binszp ;
}
* binszp + = zerocount ;
return true ;
}
static
bool my_dblsha256 ( void * hash , const void * data , size_t datasz )
std : : string dev : : toString ( string32 const & _s )
{
uint8_t buf [ 0x20 ] ;
return b58_sha256_impl ( buf , data , datasz ) & & b58_sha256_impl ( hash , buf , sizeof ( buf ) ) ;
}
int b58check ( const void * bin , size_t binsz , const char * base58str , size_t b58sz )
{
unsigned char buf [ 32 ] ;
const uint8_t * binc = bin ;
unsigned i ;
if ( binsz < 4 )
return - 4 ;
if ( ! my_dblsha256 ( buf , bin , binsz - 4 ) )
return - 2 ;
if ( memcmp ( & binc [ binsz - 4 ] , buf , 4 ) )
return - 1 ;
// Check number of zeros is correct AFTER verifying checksum (to avoid possibility of accessing base58str beyond the end)
for ( i = 0 ; binc [ i ] = = ' \0 ' & & base58str [ i ] = = ' 1 ' ; + + i )
{ } // Just finding the end of zeros, nothing to do in loop
if ( binc [ i ] = = ' \0 ' | | base58str [ i ] = = ' 1 ' )
return - 3 ;
return binc [ 0 ] ;
}
static const char b58digits_ordered [ ] = " 123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz " ;
bool b58enc ( char * b58 , size_t * b58sz , const void * data , size_t binsz )
{
const uint8_t * bin = data ;
int carry ;
size_t i , j , high , zcount = 0 ;
size_t size ;
while ( zcount < binsz & & ! bin [ zcount ] )
+ + zcount ;
size = ( binsz - zcount ) * 138 / 100 + 1 ;
uint8_t buf [ size ] ;
memset ( buf , 0 , size ) ;
for ( i = zcount , high = size - 1 ; i < binsz ; + + i , high = j )
{
for ( carry = bin [ i ] , j = size - 1 ; ( j > high ) | | carry ; - - j )
{
carry + = 256 * buf [ j ] ;
buf [ j ] = carry % 58 ;
carry / = 58 ;
}
}
for ( j = 0 ; j < size & & ! buf [ j ] ; + + j ) ;
if ( * b58sz < = zcount + size - j )
{
* b58sz = zcount + size - j + 1 ;
return false ;
}
if ( zcount )
memset ( b58 , ' 1 ' , zcount ) ;
for ( i = zcount ; j < size ; + + i , + + j )
b58 [ i ] = b58digits_ordered [ buf [ j ] ] ;
b58 [ i ] = ' \0 ' ;
* b58sz = i + 1 ;
return true ;
std : : string ret ;
for ( unsigned i = 0 ; i < 32 & & _s [ i ] ; + + i )
ret . push_back ( _s [ i ] ) ;
return ret ;
}
# endif
arkpar
10 years ago