]> Git Repo - VerusCoin.git/blob - src/base58.cpp
Major updates integration from all upstreams
[VerusCoin.git] / src / base58.cpp
1 // Copyright (c) 2014 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5 #include "base58.h"
6
7 #include <hash.h>
8 #include <uint256.h>
9
10 #include <assert.h>
11 #include <string.h>
12 #include <stdint.h>
13 #include <vector>
14 #include <string>
15 #include <boost/variant/apply_visitor.hpp>
16 #include <boost/variant/static_visitor.hpp>
17
18 /** All alphanumeric characters except for "0", "I", "O", and "l" */
19 static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
20
21 bool DecodeBase58(const char* psz, std::vector<unsigned char>& vch)
22 {
23     // Skip leading spaces.
24     while (*psz && isspace(*psz))
25         psz++;
26     // Skip and count leading '1's.
27     int zeroes = 0;
28     while (*psz == '1') {
29         zeroes++;
30         psz++;
31     }
32     // Allocate enough space in big-endian base256 representation.
33     std::vector<unsigned char> b256(strlen(psz) * 733 / 1000 + 1); // log(58) / log(256), rounded up.
34     // Process the characters.
35     while (*psz && !isspace(*psz)) {
36         // Decode base58 character
37         const char* ch = strchr(pszBase58, *psz);
38         if (ch == NULL)
39             return false;
40         // Apply "b256 = b256 * 58 + ch".
41         int carry = ch - pszBase58;
42         for (std::vector<unsigned char>::reverse_iterator it = b256.rbegin(); it != b256.rend(); it++) {
43             carry += 58 * (*it);
44             *it = carry % 256;
45             carry /= 256;
46         }
47         assert(carry == 0);
48         psz++;
49     }
50     // Skip trailing spaces.
51     while (isspace(*psz))
52         psz++;
53     if (*psz != 0)
54         return false;
55     // Skip leading zeroes in b256.
56     std::vector<unsigned char>::iterator it = b256.begin();
57     while (it != b256.end() && *it == 0)
58         it++;
59     // Copy result into output vector.
60     vch.reserve(zeroes + (b256.end() - it));
61     vch.assign(zeroes, 0x00);
62     while (it != b256.end())
63         vch.push_back(*(it++));
64     return true;
65 }
66
67 std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend)
68 {
69     // Skip & count leading zeroes.
70     int zeroes = 0;
71     while (pbegin != pend && *pbegin == 0) {
72         pbegin++;
73         zeroes++;
74     }
75     // Allocate enough space in big-endian base58 representation.
76     std::vector<unsigned char> b58((pend - pbegin) * 138 / 100 + 1); // log(256) / log(58), rounded up.
77     // Process the bytes.
78     while (pbegin != pend) {
79         int carry = *pbegin;
80         // Apply "b58 = b58 * 256 + ch".
81         for (std::vector<unsigned char>::reverse_iterator it = b58.rbegin(); it != b58.rend(); it++) {
82             carry += 256 * (*it);
83             *it = carry % 58;
84             carry /= 58;
85         }
86         assert(carry == 0);
87         pbegin++;
88     }
89     // Skip leading zeroes in base58 result.
90     std::vector<unsigned char>::iterator it = b58.begin();
91     while (it != b58.end() && *it == 0)
92         it++;
93     // Translate the result into a string.
94     std::string str;
95     str.reserve(zeroes + (b58.end() - it));
96     str.assign(zeroes, '1');
97     while (it != b58.end())
98         str += pszBase58[*(it++)];
99     return str;
100 }
101
102 std::string EncodeBase58(const std::vector<unsigned char>& vch)
103 {
104     return EncodeBase58(vch.data(), vch.data() + vch.size());
105 }
106
107 bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet)
108 {
109     return DecodeBase58(str.c_str(), vchRet);
110 }
111
112 std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn)
113 {
114     // add 4-byte hash check to the end
115     std::vector<unsigned char> vch(vchIn);
116     uint256 hash = Hash(vch.begin(), vch.end());
117     vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
118     return EncodeBase58(vch);
119 }
120
121 bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet)
122 {
123     if (!DecodeBase58(psz, vchRet) ||
124         (vchRet.size() < 4)) {
125         vchRet.clear();
126         return false;
127     }
128     // re-calculate the checksum, insure it matches the included 4-byte checksum
129     uint256 hash = Hash(vchRet.begin(), vchRet.end() - 4);
130     if (memcmp(&hash, &vchRet.end()[-4], 4) != 0) {
131         vchRet.clear();
132         return false;
133     }
134     vchRet.resize(vchRet.size() - 4);
135     return true;
136 }
137
138 bool DecodeBase58Check(const std::string& str, std::vector<unsigned char>& vchRet)
139 {
140     return DecodeBase58Check(str.c_str(), vchRet);
141 }
142
143
144 CBase58Data::CBase58Data()
145 {
146     vchVersion.clear();
147     vchData.clear();
148 }
149
150 void CBase58Data::SetData(const std::vector<unsigned char>& vchVersionIn, const void* pdata, size_t nSize)
151 {
152     vchVersion = vchVersionIn;
153     vchData.resize(nSize);
154     if (!vchData.empty())
155         memcpy(&vchData[0], pdata, nSize);
156 }
157
158 void CBase58Data::SetData(const std::vector<unsigned char>& vchVersionIn, const unsigned char* pbegin, const unsigned char* pend)
159 {
160     SetData(vchVersionIn, (void*)pbegin, pend - pbegin);
161 }
162
163 bool CBase58Data::SetString(const char* psz, unsigned int nVersionBytes)
164 {
165     std::vector<unsigned char> vchTemp;
166     bool rc58 = DecodeBase58Check(psz, vchTemp);
167     if ((!rc58) || (vchTemp.size() < nVersionBytes)) {
168         vchData.clear();
169         vchVersion.clear();
170         return false;
171     }
172     vchVersion.assign(vchTemp.begin(), vchTemp.begin() + nVersionBytes);
173     vchData.resize(vchTemp.size() - nVersionBytes);
174     if (!vchData.empty())
175         memcpy(&vchData[0], &vchTemp[nVersionBytes], vchData.size());
176     memory_cleanse(&vchTemp[0], vchData.size());
177     return true;
178 }
179
180 bool CBase58Data::SetString(const std::string& str, unsigned int nVersionBytes)
181 {
182     return SetString(str.c_str(), nVersionBytes);
183 }
184
185 std::string CBase58Data::ToString() const
186 {
187     std::vector<unsigned char> vch = vchVersion;
188     vch.insert(vch.end(), vchData.begin(), vchData.end());
189     return EncodeBase58Check(vch);
190 }
191
192 int CBase58Data::CompareTo(const CBase58Data& b58) const
193 {
194     if (vchVersion < b58.vchVersion)
195         return -1;
196     if (vchVersion > b58.vchVersion)
197         return 1;
198     if (vchData < b58.vchData)
199         return -1;
200     if (vchData > b58.vchData)
201         return 1;
202     return 0;
203 }
204
205 namespace
206 {
207 class CBitcoinAddressVisitor : public boost::static_visitor<bool>
208 {
209 private:
210     CBitcoinAddress* addr;
211
212 public:
213     CBitcoinAddressVisitor(CBitcoinAddress* addrIn) : addr(addrIn) {}
214
215     bool operator()(const CKeyID& id) const { return addr->Set(id); }
216     bool operator()(const CScriptID& id) const { return addr->Set(id); }
217     bool operator()(const CNoDestination& no) const { return false; }
218 };
219
220 } // anon namespace
221
222 bool CBitcoinAddress::Set(const CKeyID& id)
223 {
224     SetData(Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS), &id, 20);
225     return true;
226 }
227
228 bool CBitcoinAddress::Set(const CScriptID& id)
229 {
230     SetData(Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS), &id, 20);
231     return true;
232 }
233
234 bool CBitcoinAddress::Set(const CTxDestination& dest)
235 {
236     return boost::apply_visitor(CBitcoinAddressVisitor(this), dest);
237 }
238
239 bool CBitcoinAddress::IsValid() const
240 {
241     return IsValid(Params());
242 }
243
244 bool CBitcoinAddress::IsValid(const CChainParams& params) const
245 {
246     bool fCorrectSize = vchData.size() == 20;
247     bool fKnownVersion = vchVersion == params.Base58Prefix(CChainParams::PUBKEY_ADDRESS) ||
248                          vchVersion == params.Base58Prefix(CChainParams::SCRIPT_ADDRESS);
249     return fCorrectSize && fKnownVersion;
250 }
251
252 bool CBitcoinAddress::SetString(const char* pszAddress)
253 {
254     return CBase58Data::SetString(pszAddress, 1);//2);
255 }
256
257 bool CBitcoinAddress::SetString(const std::string& strAddress)
258 {
259     return SetString(strAddress.c_str());
260 }
261
262 CTxDestination CBitcoinAddress::Get() const
263 {
264     if (!IsValid())
265         return CNoDestination();
266     uint160 id;
267     memcpy(&id, &vchData[0], 20);
268     if (vchVersion == Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS))
269         return CKeyID(id);
270     else if (vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS))
271         return CScriptID(id);
272     else
273         return CNoDestination();
274 }
275
276 bool CBitcoinAddress::GetIndexKey(uint160& hashBytes, int& type) const
277 {
278     if (!IsValid()) {
279         return false;
280     } else if (vchVersion == Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS)) {
281         memcpy(&hashBytes, &vchData[0], 20);
282         type = 1;
283         return true;
284     } else if (vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS)) {
285         memcpy(&hashBytes, &vchData[0], 20);
286         type = 2;
287         return true;
288     }
289
290     return false;
291 }
292
293 bool CBitcoinAddress::GetKeyID(CKeyID& keyID) const
294 {
295     if (!IsValid() || vchVersion != Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS))
296         return false;
297     uint160 id;
298     memcpy(&id, &vchData[0], 20);
299     keyID = CKeyID(id);
300     return true;
301 }
302
303 bool CBitcoinAddress::GetKeyID_NoCheck(CKeyID& keyID) const
304 {
305     uint160 id;
306     memcpy(&id, &vchData[0], 20);
307     keyID = CKeyID(id);
308     return true;
309 }
310
311 bool CBitcoinAddress::IsScript() const
312 {
313     return IsValid() && vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS);
314 }
315
316 void CBitcoinSecret::SetKey(const CKey& vchSecret)
317 {
318     assert(vchSecret.IsValid());
319     SetData(Params().Base58Prefix(CChainParams::SECRET_KEY), vchSecret.begin(), vchSecret.size());
320     if (vchSecret.IsCompressed())
321         vchData.push_back(1);
322 }
323
324 CKey CBitcoinSecret::GetKey()
325 {
326     CKey ret;
327     assert(vchData.size() >= 32);
328     ret.Set(vchData.begin(), vchData.begin() + 32, vchData.size() > 32 && vchData[32] == 1);
329     return ret;
330 }
331
332 bool CBitcoinSecret::IsValid() const
333 {
334     bool fExpectedFormat = vchData.size() == 32 || (vchData.size() == 33 && vchData[32] == 1);
335     bool fCorrectVersion = vchVersion == Params().Base58Prefix(CChainParams::SECRET_KEY);
336     return fExpectedFormat && fCorrectVersion;
337 }
338
339 bool CBitcoinSecret::SetString(const char* pszSecret)
340 {
341     return CBase58Data::SetString(pszSecret, 1) && IsValid();
342 }
343
344 bool CBitcoinSecret::SetString(const std::string& strSecret)
345 {
346     return SetString(strSecret.c_str());
347 }
348
349 template<class DATA_TYPE, CChainParams::Base58Type PREFIX, size_t SER_SIZE>
350 bool CZCEncoding<DATA_TYPE, PREFIX, SER_SIZE>::Set(const DATA_TYPE& addr)
351 {
352     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
353     ss << addr;
354     std::vector<unsigned char> addrSerialized(ss.begin(), ss.end());
355     assert(addrSerialized.size() == SER_SIZE);
356     SetData(Params().Base58Prefix(PREFIX), &addrSerialized[0], SER_SIZE);
357     return true;
358 }
359
360 template<class DATA_TYPE, CChainParams::Base58Type PREFIX, size_t SER_SIZE>
361 DATA_TYPE CZCEncoding<DATA_TYPE, PREFIX, SER_SIZE>::Get() const
362 {
363     if (vchData.size() != SER_SIZE) {
364         throw std::runtime_error(
365             PrependName(" is invalid")
366         );
367     }
368
369     if (vchVersion != Params().Base58Prefix(PREFIX)) {
370         throw std::runtime_error(
371             PrependName(" is for wrong network type")
372         );
373     }
374
375     std::vector<unsigned char> serialized(vchData.begin(), vchData.end());
376
377     CDataStream ss(serialized, SER_NETWORK, PROTOCOL_VERSION);
378     DATA_TYPE ret;
379     ss >> ret;
380     return ret;
381 }
This page took 0.046167 seconds and 4 git commands to generate.