Java tutorial
/* * This file is part of Bitsquare. * * Bitsquare is free software: you can redistribute it and/or modify it * under the terms of the GNU Affero General Public License as published by * the Free Software Foundation, either version 3 of the License, or (at * your option) any later version. * * Bitsquare is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public * License for more details. * * You should have received a copy of the GNU Affero General Public License * along with Bitsquare. If not, see <http://www.gnu.org/licenses/>. */ package io.bitsquare.gui.util.validation.altcoins; import io.bitsquare.gui.util.validation.InputValidator; import org.apache.commons.codec.binary.Base32; import org.apache.commons.codec.binary.Base64; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * Created by DevAlexey on 19.12.2016. */ public class ByteballAddressValidator { private static final Base32 base32 = new Base32(); private static final Base64 base64 = new Base64(); private static final String PI = "14159265358979323846264338327950288419716939937510"; private static final String[] arrRelativeOffsets = PI.split(""); private static Integer[] arrOffsets160, arrOffsets288; static { try { arrOffsets160 = calcOffsets(160); } catch (Exception e) { e.printStackTrace(); } try { arrOffsets288 = calcOffsets(288); } catch (Exception e) { e.printStackTrace(); } } public static InputValidator.ValidationResult validate(String input) { return new InputValidator.ValidationResult(isValidAddress(input)); } private static boolean isValidAddress(String address) { return isValidChash(address, 32); } private static boolean isValidChash(String str, int len) { return (isStringOfLength(str, len) && isChashValid(str)); } private static boolean isStringOfLength(String str, int len) { return str.length() == len; } private static void checkLength(int chash_length) throws Exception { if (chash_length != 160 && chash_length != 288) throw new Exception("unsupported c-hash length: " + chash_length); } private static Integer[] calcOffsets(int chash_length) throws Exception { checkLength(chash_length); List<Integer> arrOffsets = new ArrayList<>(chash_length); int offset = 0; int index = 0; for (int i = 0; offset < chash_length; i++) { int relative_offset = Integer.parseInt(arrRelativeOffsets[i]); if (relative_offset == 0) continue; offset += relative_offset; if (chash_length == 288) offset += 4; if (offset >= chash_length) break; arrOffsets.add(offset); //console.log("index="+index+", offset="+offset); index++; } if (index != 32) throw new Exception("wrong number of checksum bits"); return arrOffsets.toArray(new Integer[0]); } private static SeparatedData separateIntoCleanDataAndChecksum(String bin) throws Exception { int len = bin.length(); Integer[] arrOffsets; if (len == 160) arrOffsets = arrOffsets160; else if (len == 288) arrOffsets = arrOffsets288; else throw new Exception("bad length"); StringBuilder arrFrags = new StringBuilder(); StringBuilder arrChecksumBits = new StringBuilder(); int start = 0; for (int i = 0; i < arrOffsets.length; i++) { arrFrags.append(bin.substring(start, arrOffsets[i])); arrChecksumBits.append(bin.substring(arrOffsets[i], arrOffsets[i] + 1)); start = arrOffsets[i] + 1; } // add last frag if (start < bin.length()) arrFrags.append(bin.substring(start)); String binCleanData = arrFrags.toString(); String binChecksum = arrChecksumBits.toString(); return new SeparatedData(binCleanData, binChecksum); } private static String buffer2bin(byte[] buf) { StringBuffer bytes = new StringBuffer(); for (int i = 0; i < buf.length; i++) { String bin = String.format("%8s", Integer.toBinaryString(buf[i] & 0xFF)).replace(' ', '0'); bytes.append(bin); } return bytes.toString(); } private static byte[] bin2buffer(String bin) { int len = bin.length() / 8; byte[] buf = new byte[len]; for (int i = 0; i < len; i++) buf[i] = (byte) Integer.parseInt(bin.substring(i * 8, (i + 1) * 8), 2); return buf; } private static boolean isChashValid(String encoded) { int encoded_len = encoded.length(); if (encoded_len != 32 && encoded_len != 48) // 160/5 = 32, 288/6 = 48 return false; byte[] chash = (encoded_len == 32) ? base32.decode(encoded) : base64.decode(encoded); String binChash = buffer2bin(chash); SeparatedData separated = null; try { separated = separateIntoCleanDataAndChecksum(binChash); } catch (Exception e) { return false; } byte[] clean_data = bin2buffer(separated.clean_data); byte[] checksum = bin2buffer(separated.checksum); return Arrays.equals(getChecksum(clean_data), checksum); } private static byte[] getChecksum(byte[] clean_data) { try { byte[] full_checksum = MessageDigest.getInstance("SHA-256").digest(clean_data); byte[] checksum = { full_checksum[5], full_checksum[13], full_checksum[21], full_checksum[29] }; return checksum; } catch (NoSuchAlgorithmException e) { return null; } } private static class SeparatedData { String clean_data, checksum; public SeparatedData(String clean_data, String checksum) { this.clean_data = clean_data; this.checksum = checksum; } } }