Bitcoin/address validation (2024)

Bitcoin/address validation
You are encouraged to solve this task according to the task description, using any language you may know.

It doesn't belong to anyone and is part of the test suite of the bitcoin software.
You can change a few characters in this string and check that it'll fail the test.

with Ada.Exceptions, Interfaces;with Ada.Streams;use Ada.Exceptions, Interfaces;use Ada.Streams;package Bitcoin is subtype BT_Raw_Addr is Stream_Element_Array(1..25); subtype BT_Checksum is Stream_Element_Array(1..4); subtype BT_Addr is String(1..34); subtype Sha256String is String(1..64); Invalid_Address_Error : Exception; function Double_Sha256(S : Stream_Element_Array) return BT_Checksum; function Is_Valid(A : BT_Raw_Addr) return Boolean; procedure Base58_Decode(S : BT_Addr; A : out BT_Raw_Addr) ;private Base58 : constant String := "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; function Hex_Val (C, C2 : Character) return Stream_Element;end Bitcoin;with GNAT.SHA256, Ada.Strings.Fixed;use GNAT.SHA256, Ada.Strings.Fixed;package body Bitcoin isfunction Hex_Val (C, C2 : Character) return Stream_Element is subtype Nibble is Integer range 0..15; HEX : array (0..255) of Nibble := ( 48=>0, 49=>1, 50=>2, 51=>3, 52=>4, 53=>5, 54=>6, 55=>7, 56=>8, 57=>9 , 65=>10, 66=>11, 67=>12, 68 =>13, 69 =>14, 70 =>15 , 97=>10, 98=>11, 99=>12, 100=>13, 101=>14, 102=>15 , Others=>0 );begin return Stream_Element(HEX(Character'Pos(C)) * 16 + HEX(Character'Pos(C2)));end Hex_Val;function Double_Sha256(S : Stream_Element_Array) return BT_Checksum is Ctx : Context := Initial_Context; D : Message_Digest; S2 : Stream_Element_Array(1..32); Ctx2 : Context := Initial_Context; C : BT_Checksum;begin Update(Ctx, S); D := Digest(Ctx); for I in S2'Range loop S2(I) := Hex_Val(D(Integer(I)*2-1), D(Integer(I)*2)); end loop; Update(Ctx2, S2); D := Digest(Ctx2); for I in C'Range loop C(I) := Hex_Val(D(Integer(I)*2-1), D(Integer(I)*2)); end loop; return C;end Double_Sha256;---------------------------------------------------------------------------------- Summary of Base58: ---- We decode S into a 200 bit unsigned integer. ---- We could use a BigNum library, but choose to go without. ----------------------------------------------------------------------------------procedure Base58_Decode(S : BT_Addr; A : out BT_Raw_Addr) isbegin A := (Others => 0); for I in S'Range loop declare P : Natural := Index(Base58, String(S(I..I))); C : Natural; begin if P = 0 then raise Invalid_Address_Error; end if; C := P - 1; for J in reverse A'Range loop C := C + Natural(A(J)) * 58; A(J) := Stream_Element(Unsigned_32(C) and 255); -- 0x00FF C := Natural(Shift_Right(Unsigned_32(C),8) and 255); -- 0xFF00 end loop; if C /= 0 then raise Invalid_Address_Error; end if; end; end loop;end Base58_Decode;function Is_Valid(A : BT_Raw_Addr) return Boolean isbegin return A(1) = 0 and A(22..25) = Double_Sha256(A(1..21));end Is_Valid;end Bitcoin;with Ada.Text_IO, Bitcoin;use Ada.Text_IO, Bitcoin;procedure Bitcoin_Addr_Validate isbegin declare BTs : array (positive range <>) of BT_Addr := ( "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -- VALID , "1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nK9" -- VALID , "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62X" -- checksum changed, original data. , "1ANNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -- data changed, original checksum. , "1A Na15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" -- invalid chars ); begin for I in Bts'Range loop declare A : BT_Raw_Addr; Valid : Boolean; begin Put(BTs(I) & " validity: "); Base58_Decode(BTs(I), A); Valid := Is_Valid(A); Put_Line(Boolean'Image(Valid)); exception when E : Invalid_Address_Error => Put_Line ("*** Error: Invalid BT address."); end; end loop; end;end Bitcoin_Addr_Validate;

Output:

#include <stdio.h>#include <string.h>#include <openssl/sha.h>const char *coin_err;#define bail(s) { coin_err = s; return 0; }int unbase58(const char *s, unsigned char *out) {static const char *tmpl = "123456789""ABCDEFGHJKLMNPQRSTUVWXYZ""abcdefghijkmnopqrstuvwxyz";int i, j, c;const char *p;memset(out, 0, 25);for (i = 0; s[i]; i++) {if (!(p = strchr(tmpl, s[i])))bail("bad char");c = p - tmpl;for (j = 25; j--; ) {c += 58 * out[j];out[j] = c % 256;c /= 256;}if (c) bail("address too long");}return 1;}int valid(const char *s) {unsigned char dec[32], d1[SHA256_DIGEST_LENGTH], d2[SHA256_DIGEST_LENGTH];coin_err = "";if (!unbase58(s, dec)) return 0;SHA256(SHA256(dec, 21, d1), SHA256_DIGEST_LENGTH, d2);if (memcmp(dec + 21, d2, 4))bail("bad digest");return 1;}int main (void) {const char *s[] = {"1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nK9","1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i","1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nJ9","1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62I",0 };int i;for (i = 0; s[i]; i++) {int status = valid(s[i]);printf("%s: %s\n", s[i], status ? "Ok" : coin_err);}return 0;}

Output:

using System;using System.Linq;using System.Security.Cryptography;using NUnit.Framework;namespace BitcoinValidator{ public class ValidateTest { [TestCase] public void ValidateBitcoinAddressTest() { Assert.IsTrue(ValidateBitcoinAddress("1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i")); // VALID Assert.IsTrue(ValidateBitcoinAddress("1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nK9")); // VALID Assert.Throws<Exception>(() => ValidateBitcoinAddress("1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62X")); // checksum changed, original data Assert.Throws<Exception>(() => ValidateBitcoinAddress("1ANNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i")); // data changed, original checksum Assert.Throws<Exception>(() => ValidateBitcoinAddress("1A Na15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i")); // invalid chars Assert.Throws<Exception>(() => ValidateBitcoinAddress("BZbvjr")); // checksum is fine, address too short } public static bool ValidateBitcoinAddress(string address) { if (address.Length < 26 || address.Length > 35) throw new Exception("wrong length"); var decoded = DecodeBase58(address); var d1 = Hash(decoded.SubArray(0, 21)); var d2 = Hash(d1); if (!decoded.SubArray(21, 4).SequenceEqual(d2.SubArray(0, 4))) throw new Exception("bad digest"); return true; } const string Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; const int Size = 25; private static byte[] DecodeBase58(string input) { var output = new byte[Size]; foreach (var t in input) { var p = Alphabet.IndexOf(t); if (p == -1) throw new Exception("invalid character found"); var j = Size; while (--j > 0) { p += 58 * output[j]; output[j] = (byte)(p % 256); p /= 256; } if (p != 0) throw new Exception("address too long"); } return output; } private static byte[] Hash(byte[] bytes) { var hasher = new SHA256Managed(); return hasher.ComputeHash(bytes); } } public static class ArrayExtensions { public static T[] SubArray<T>(this T[] data, int index, int length) { var result = new T[length]; Array.Copy(data, index, result, 0, length); return result; } }}

#include <algorithm>#include <cstdint>#include <iostream>#include <map>#include <stdexcept>#include <string>#include <vector>#include "SHA256.cpp"SHA256 sha256{ };const std::string ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";std::map<char, uint32_t> base_map ={ { '0', 0 }, { '1', 1 }, { '2', 2 }, { '3', 3 }, { '4', 4 }, { '5', 5 }, { '6', 6 }, { '7', 7 },{ '8', 8 }, { '9', 9 }, { 'a', 10 }, { 'b', 11 }, { 'c', 12 }, { 'd', 13 }, { 'e', 14 }, { 'f', 15 },{ 'A', 10 }, { 'B', 11 }, { 'C', 12 }, { 'D', 13 }, { 'E', 14 }, { 'F', 15 } };std::vector<uint32_t> hex_to_bytes(const std::string& text) {std::vector<uint32_t> bytes(text.size() / 2, 0);for ( uint64_t i = 0; i < text.size(); i += 2 ) { const uint32_t first_digit = base_map[text[i]]; const uint32_t second_digit = base_map[text[i + 1]]; bytes[i / 2] = ( first_digit << 4 ) + second_digit;}return bytes;}std::string vector_to_ascii_string(const std::vector<uint32_t>& bytes) {std::string result = "";for ( uint32_t i = 0; i < bytes.size(); ++i ) {result += static_cast<char>(bytes[i]);}return result;}std::vector<uint32_t> decode_base_58(const std::string& text) {std::vector<uint32_t> result(25, 0);for ( const char& ch : text ) {std::string::size_type index = ALPHABET.find(ch);if ( index == static_cast<uint64_t>(-1) ) {throw std::invalid_argument("Invalid character found in bitcoin address");}for ( uint64_t i = result.size() - 1; i > 0; i-- ) {index += 58 * result[i];result[i] = index & 0xFF;index >>= 8;}if ( index != 0 ) {throw std::invalid_argument("Bitcoin address is too long");}}return result;}bool is_valid(const std::string& address) {if ( address.size() < 26 || address.size() > 35 ) {throw std::invalid_argument("Invalid length of bitcoin address");}std::vector<uint32_t> decoded = decode_base_58(address);std::vector first21(decoded.begin(), decoded.begin() + 21);// Convert the 'first21' into a suitable ASCII string for the first SHA256 hashstd::string text = vector_to_ascii_string(first21);std::string hash_1 = sha256.message_digest(text);// Convert 'hashOne' into a suitable ASCII string for the second SHA256 hashstd::vector<uint32_t> bytes_1 = hex_to_bytes(hash_1);std::string ascii_1 = vector_to_ascii_string(bytes_1);std::string hash_2 = sha256.message_digest(ascii_1);std::vector<uint32_t> bytes_2 = hex_to_bytes(hash_2);std::vector<uint32_t> checksum(bytes_2.begin(), bytes_2.begin() + 4);std::vector<uint32_t> last4(decoded.begin() + 21, decoded.begin() + 25);return checksum == last4;}int main() {const std::vector<std::string> addresses = { "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i", "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62j", "1Q1pE5vPGEEMqRcVRMbtBK842Y6Pzo6nK9", "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62X", "1ANNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" };for ( const std::string& address : addresses ) {std::cout << address << ": " << std::boolalpha << is_valid(address) << std::endl;}}

Output:

import std.stdio, std.algorithm, std.array, std.string, sha_256_2;struct A25 { // Type for a 25 ubyte (not base58 encoded) bitcoin address. ubyte[25] enc; ubyte bitcoinVersion() const pure nothrow @safe @nogc { return enc[0]; } ubyte[4] embeddedChecksum() return const pure nothrow @safe @nogc { return enc[$ - 4 .. $]; } /** Computes a double sha256 hash of the first 21 bytes of the address. Returns the full 32 ubyte sha256 hash. */ ubyte[32] doubleSHA256() const pure nothrow @nogc { return SHA256.digest(SHA256.digest(enc[0 .. 21])); } /** Returns a four ubyte checksum computed from the first 21 bytes of the address. */ ubyte[4] computeChecksum() const pure nothrow @nogc { return doubleSHA256[0 .. 4]; } /** Takes a base58 encoded address and decodes it into the receiver. Errors are returned if the argument is not valid base58 or if the decoded value does not fit in the 25 ubyte address. The address is not otherwise checked for validity. */ string set58(in ubyte[] s) pure nothrow @safe @nogc { static immutable digits = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" .representation; static assert(digits.length == 58); foreach (immutable char s1; s) { immutable c = digits.countUntil(s1); if (c < 0) return "found a bad char in the Bitcoin address."; // Currently the D type system can't see c as nonegative. uint uc = (c < 0) ? 0 : c; foreach_reverse (ref aj; enc) { uc += digits.length * aj; aj = uc % 256; uc /= 256; } if (uc > 0) return "too long Bitcoin address."; } return null; }}/** Validates a base58 encoded bitcoin address. An address is validif it can be decoded into a 25 ubyte address, the Version number is 0,and the checksum validates. Return value ok will be true for validaddresses. If ok is false, the address is invalid and the error valuemay indicate why. */string isValidA58(in ubyte[] a58) pure nothrow @nogc { A25 a; immutable err = a.set58(a58); if (!err.empty) return err; if (a.bitcoinVersion != 0) return "not Bitcoin version 0."; return (a.embeddedChecksum == a.computeChecksum) ? null : "checksums don't match.";}void main() { immutable tests = ["1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i", "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62j", "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62!", "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62iz", "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62izz"]; foreach (immutable test; tests) { immutable err = test.representation.isValidA58; writefln(`"%s": %s`, test, err.empty ? "OK." : err); }}

Output:

import 'package:crypto/crypto.dart';class Bitcoin { final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; List<int> bigIntToByteArray(BigInt data) { String str; bool neg = false; if (data < BigInt.zero) { str = (~data).toRadixString(16); neg = true; } else str = data.toRadixString(16); int p = 0; int len = str.length; int blen = (len + 1) ~/ 2; int boff = 0; List bytes; if (neg) { if (len & 1 == 1) { p = -1; } int byte0 = ~int.parse(str.substring(0, p + 2), radix: 16); if (byte0 < -128) byte0 += 256; if (byte0 >= 0) { boff = 1; bytes = new List<int>(blen + 1); bytes[0] = -1; bytes[1] = byte0; } else { bytes = new List<int>(blen); bytes[0] = byte0; } for (int i = 1; i < blen; ++i) { int byte = ~int.parse(str.substring(p + (i << 1), p + (i << 1) + 2), radix: 16); if (byte < -128) byte += 256; bytes[i + boff] = byte; } } else { if (len & 1 == 1) { p = -1; } int byte0 = int.parse(str.substring(0, p + 2), radix: 16); if (byte0 > 127) byte0 -= 256; if (byte0 < 0) { boff = 1; bytes = new List<int>(blen + 1); bytes[0] = 0; bytes[1] = byte0; } else { bytes = new List<int>(blen); bytes[0] = byte0; } for (int i = 1; i < blen; ++i) { int byte = int.parse(str.substring(p + (i << 1), p + (i << 1) + 2), radix: 16); if (byte > 127) byte -= 256; bytes[i + boff] = byte; } } return bytes; } List<int> arrayCopy(bytes, srcOffset, result, destOffset, bytesLength) { for (int i = srcOffset; i < bytesLength; i++) { result[destOffset + i] = bytes[i]; } return result; } List<int> decodeBase58To25Bytes(String input) { BigInt number = BigInt.zero; for (String t in input.split('')) { int p = ALPHABET.indexOf(t); if (p == (-1)) return null; number = number * (BigInt.from(58)) + (BigInt.from(p)); } List<int> result = new List<int>(24); List<int> numBytes = bigIntToByteArray(number); return arrayCopy( numBytes, 0, result, result.length - numBytes.length, numBytes.length); } validateAddress(String address) { List<int> decoded = new List.from(decodeBase58To25Bytes(address)); List<int> temp = new List<int>.from(decoded); temp.insert(0, 0); List<int> hash1 = sha256.convert(temp.sublist(0, 21)).bytes; List<int> hash2 = sha256.convert(hash1).bytes; if (hash2[0] != decoded[20] || hash2[1] != decoded[21] || hash2[2] != decoded[22] || hash2[3] != decoded[23]) return false; return true; }}

Output:

uses DCPsha256;type TByteArray = array of Byte;function HashSHA256(const Input: TByteArray): TByteArray;var Hasher: TDCP_sha256;begin Hasher := TDCP_sha256.Create(nil); try Hasher.Init; Hasher.Update(Input[0], Length(Input)); SetLength(Result, Hasher.HashSize div 8); Hasher.Final(Result[0]); finally Hasher.Free; end;end;function DecodeBase58(const Input: string): TByteArray;const Size = 25; Alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';var C: Char; I, J: Integer;begin SetLength(Result, Size); for C in Input do begin I := Pos(C, Alphabet) - 1; if I = -1 then raise Exception.CreateFmt('Invalid character found: %s', [C]); for J := High(Result) downto 0 do begin I := I + (58 * Result[J]); Result[J] := I mod 256; I := I div 256; end; if I <> 0 then raise Exception.Create('Address too long'); end;end;procedure ValidateBitcoinAddress(const Address: string);var Hashed: TByteArray; Decoded: TByteArray;begin if (Length(Address) < 26) or (Length(Address) > 35) then raise Exception.Create('Wrong length'); Decoded := DecodeBase58(Address); Hashed := HashSHA256(HashSHA256(Copy(Decoded, 0, 21))); if not CompareMem(@Decoded[21], @Hashed[0], 4) then raise Exception.Create('Bad digest');end;

-module( bitcoin_address ).-export( [task/0, validate/1] ).task() ->io:fwrite( "Validate ~p~n", ["1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i"] ),io:fwrite( "~p~n", [validate("1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i")] ),io:fwrite( "Validate ~p~n", ["1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW622"] ),io:fwrite( "~p~n", [validate("1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW622")] ).validate( String ) ->{length_25, <<Address:21/binary, Checksum:4/binary>>} = {length_25, base58:base58_to_binary( String )},<<Version:1/binary, _/binary>> = Address,{version_0, <<0>>} = {version_0, Version},<<Four_bytes:4/binary, _T/binary>> = crypto:hash( sha256, crypto:hash(sha256, Address) ),{checksum, Checksum} = {checksum, Four_bytes},ok.

Output:

USING: byte-arrays checksums checksums.sha io.binary kernel mathmath.parser sequences ;IN: rosetta-code.bitcoin.validationCONSTANT: ALPHABET "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz": base58>bigint ( str -- n ) [ ALPHABET index ] [ [ 58 * ] [ + ] bi* ] map-reduce ;: base58> ( str -- bytes ) base58>bigint 25 >be ;: btc-checksum ( bytes -- checksum-bytes ) 21 head 2 [ sha-256 checksum-bytes ] times 4 head ;: btc-valid? ( str -- ? ) base58> [ btc-checksum ] [ 4 tail* ] bi = ;

Output:

' version 05-04-2017' compile with: fbc -s console' function adapted from the SHA-256 taskFunction SHA_256(test_str As String, bitcoin As ULong = 0) As String #Macro Ch (x, y, z) (((x) And (y)) Xor ((Not (x)) And z)) #EndMacro #Macro Maj (x, y, z) (((x) And (y)) Xor ((x) And (z)) Xor ((y) And (z))) #EndMacro #Macro sigma0 (x) (((x) Shr 2 Or (x) Shl 30) Xor ((x) Shr 13 Or (x) Shl 19) Xor ((x) Shr 22 Or (x) Shl 10)) #EndMacro #Macro sigma1 (x) (((x) Shr 6 Or (x) Shl 26) Xor ((x) Shr 11 Or (x) Shl 21) Xor ((x) Shr 25 Or (x) Shl 7)) #EndMacro #Macro sigma2 (x) (((x) Shr 7 Or (x) Shl 25) Xor ((x) Shr 18 Or (x) Shl 14) Xor ((x) Shr 3)) #EndMacro #Macro sigma3 (x) (((x) Shr 17 Or (x) Shl 15) Xor ((x) Shr 19 Or (x) Shl 13) Xor ((x) Shr 10)) #EndMacro Dim As String message = test_str ' strings are passed as ByRef's Dim As Long i, j Dim As UByte Ptr ww1 Dim As UInteger<32> Ptr ww4 Do Dim As ULongInt l = Len(message) ' set the first bit after the message to 1 message = message + Chr(1 Shl 7) ' add one char to the length Dim As ULong padding = 64 - ((l +1) Mod (512 \ 8)) ' 512 \ 8 = 64 char. ' check if we have enough room for inserting the length If padding < 8 Then padding = padding + 64 message = message + String(padding, Chr(0)) ' adjust length Dim As ULong l1 = Len(message) ' new length l = l * 8 ' orignal length in bits ' create ubyte ptr to point to l ( = length in bits) Dim As UByte Ptr ub_ptr = Cast(UByte Ptr, @l) For i = 0 To 7 'copy length of message to the last 8 bytes message[l1 -1 - i] = ub_ptr[i] Next 'table of constants Dim As UInteger<32> K(0 To ...) = _ { &H428a2f98, &H71374491, &Hb5c0fbcf, &He9b5dba5, &H3956c25b, &H59f111f1, _ &H923f82a4, &Hab1c5ed5, &Hd807aa98, &H12835b01, &H243185be, &H550c7dc3, _ &H72be5d74, &H80deb1fe, &H9bdc06a7, &Hc19bf174, &He49b69c1, &Hefbe4786, _ &H0fc19dc6, &H240ca1cc, &H2de92c6f, &H4a7484aa, &H5cb0a9dc, &H76f988da, _ &H983e5152, &Ha831c66d, &Hb00327c8, &Hbf597fc7, &Hc6e00bf3, &Hd5a79147, _ &H06ca6351, &H14292967, &H27b70a85, &H2e1b2138, &H4d2c6dfc, &H53380d13, _ &H650a7354, &H766a0abb, &H81c2c92e, &H92722c85, &Ha2bfe8a1, &Ha81a664b, _ &Hc24b8b70, &Hc76c51a3, &Hd192e819, &Hd6990624, &Hf40e3585, &H106aa070, _ &H19a4c116, &H1e376c08, &H2748774c, &H34b0bcb5, &H391c0cb3, &H4ed8aa4a, _ &H5b9cca4f, &H682e6ff3, &H748f82ee, &H78a5636f, &H84c87814, &H8cc70208, _ &H90befffa, &Ha4506ceb, &Hbef9a3f7, &Hc67178f2 } Dim As UInteger<32> h0 = &H6a09e667 Dim As UInteger<32> h1 = &Hbb67ae85 Dim As UInteger<32> h2 = &H3c6ef372 Dim As UInteger<32> h3 = &Ha54ff53a Dim As UInteger<32> h4 = &H510e527f Dim As UInteger<32> h5 = &H9b05688c Dim As UInteger<32> h6 = &H1f83d9ab Dim As UInteger<32> h7 = &H5be0cd19 Dim As UInteger<32> a, b, c, d, e, f, g, h Dim As UInteger<32> t1, t2, w(0 To 63) For j = 0 To (l1 -1) \ 64 ' split into block of 64 bytes ww1 = Cast(UByte Ptr, @message[j * 64]) ww4 = Cast(UInteger<32> Ptr, @message[j * 64]) For i = 0 To 60 Step 4 'little endian -> big endian Swap ww1[i ], ww1[i +3] Swap ww1[i +1], ww1[i +2] Next For i = 0 To 15 ' copy the 16 32bit block into the array W(i) = ww4[i] Next For i = 16 To 63 ' fill the rest of the array w(i) = sigma3(W(i -2)) + W(i -7) + sigma2(W(i -15)) + W(i -16) Next a = h0 : b = h1 : c = h2 : d = h3 : e = h4 : f = h5 : g = h6 : h = h7 For i = 0 To 63 t1 = h + sigma1(e) + Ch(e, f, g) + K(i) + W(i) t2 = sigma0(a) + Maj(a, b, c) h = g : g = f : f = e e = d + t1 d = c : c = b : b = a a = t1 + t2 Next h0 += a : h1 += b : h2 += c : h3 += d h4 += e : h5 += f : h6 += g : h7 += h Next j Dim As String answer = Hex(h0, 8) + Hex(h1, 8) + Hex(h2, 8) + Hex(h3, 8) _ + Hex(h4, 8) + Hex(h5, 8) + Hex(h6, 8) + Hex(h7, 8) If bitcoin = 0 Then Return LCase(answer) Else 'conver hex value's to integer value's message = String(32,0) For i = 0 To 31 message[i] = Val("&h" + Mid(answer, i * 2 + 1, 2)) Next bitcoin = 0 End If LoopEnd FunctionFunction conv_base58(bitcoin_address As String) As String Dim As String base58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" Dim As String tmp = String(24, 0) Dim As Long x, y, z For x = 1 To Len(bitcoin_address) -1 z = InStr(base58, Chr(bitcoin_address[x])) -1 If z = -1 Then Print " bitcoin address contains illegal character" Return "" End If For y = 23 To 0 Step -1 z = z + tmp[y] * 58 tmp[y] = z And 255 ' test_str[y] = z Mod 256 z Shr= 8 ' z \= 256 Next If z <> 0 Then Print " bitcoin address is to long" Return "" End If Next z = InStr(base58, Chr(bitcoin_address[0])) -1 Return Chr(z) + tmpEnd Function' ------=< MAIN >=------Data "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" ' originalData "1AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62j" ' checksum changedData "1NAGa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" ' address changedData "0AGNa15ZQXAZUgFiqJ2i7Z2DPU2J6hW62i" ' only 1 or 3 as first char. allowedData "1AGNa15ZQXAZUgFlqJ2i7Z2DPU2J6hW62i" ' illegal character in addressDim As String tmp, result, checksum, bitcoin_addressDim As Long i, jFor i = 1 To 5 Read bitcoin_address Print "Bitcoin address: "; bitcoin_address; tmp = Left(bitcoin_address,1) If tmp <> "1" And tmp <> "3" Then Print " first character is not 1 or 3" Continue For End If ' convert bitcoinaddress tmp = conv_base58(bitcoin_address) If tmp = "" Then Continue For ' get the checksum, last 4 digits For j As Long = 21 To 24 checksum = checksum + LCase(Hex(tmp[j], 2)) Next ' send the first 21 characters to the SHA 256 routine result = SHA_256(Left(tmp, 21), 2) result = Left(result, 8) ' get the checksum (the first 8 digits (hex)) If checksum = result Then ' test the found checksum against Print " is valid" ' the one from the address Else Print " is not valid, checksum fails" End IfNext' empty keyboard bufferWhile InKey <> "" : WendPrint : Print "hit any key to end program"SleepEnd

Output:

package mainimport ( "bytes" "crypto/sha256" "errors" "os")// With at least one other bitcoin RC task, this source is styled more like// a package to show how functions of the two tasks might be combined into// a single package. It turns out there's not really that much shared code,// just the A25 type and doubleSHA256 method, but it's enough to suggest how// the code might be organized. Types, methods, and functions are capitalized// where they might be exported from a package.// A25 is a type for a 25 byte (not base58 encoded) bitcoin address.type A25 [25]byte func (a *A25) Version() byte { return a[0]} func (a *A25) EmbeddedChecksum() (c [4]byte) { copy(c[:], a[21:]) return}// DoubleSHA256 computes a double sha256 hash of the first 21 bytes of the// address. This is the one function shared with the other bitcoin RC task.// Returned is the full 32 byte sha256 hash. (The bitcoin checksum will be// the first four bytes of the slice.)func (a *A25) doubleSHA256() []byte { h := sha256.New() h.Write(a[:21]) d := h.Sum([]byte{}) h = sha256.New() h.Write(d) return h.Sum(d[:0])}// ComputeChecksum returns a four byte checksum computed from the first 21// bytes of the address. The embedded checksum is not updated.func (a *A25) ComputeChecksum() (c [4]byte) { copy(c[:], a.doubleSHA256()) return}/* {{header|Go}} */ // Tmpl and Set58 are adapted from the C solution.// Go has big integers but this techinique seems better.var tmpl = []byte("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")// Set58 takes a base58 encoded address and decodes it into the receiver.// Errors are returned if the argument is not valid base58 or if the decoded// value does not fit in the 25 byte address. The address is not otherwise// checked for validity.func (a *A25) Set58(s []byte) error { for _, s1 := range s { c := bytes.IndexByte(tmpl, s1) if c < 0 { return errors.New("bad char") } for j := 24; j >= 0; j-- { c += 58 * int(a[j]) a[j] = byte(c % 256) c /= 256 } if c > 0 { return errors.New("too long") } } return nil}// ValidA58 validates a base58 encoded bitcoin address. An address is valid// if it can be decoded into a 25 byte address, the version number is 0,// and the checksum validates. Return value ok will be true for valid// addresses. If ok is false, the address is invalid and the error value// may indicate why.func ValidA58(a58 []byte) (ok bool, err error) { var a A25 if err := a.Set58(a58); err != nil { return false, err } if a.Version() != 0 { return false, errors.New("not version 0") } return a.EmbeddedChecksum() == a.ComputeChecksum(), nil}// Program returns exit code 0 with valid address and produces no output.// Otherwise exit code is 1 and a message is written to stderr.func main() { if len(os.Args) != 2 { errorExit("Usage: valid <base58 address>") } switch ok, err := ValidA58([]byte(os.Args[1])); { case ok: case err == nil: errorExit("Invalid") default: errorExit(err.Error()) }}func errorExit(m string) { os.Stderr.WriteString(m + "\n") os.Exit(1)}