Repository: QuincySx/BlockchainWallet-Crypto Branch: master Commit: 8025525c2746 Files: 122 Total size: 650.3 KB Directory structure: gitextract_ei6psuhp/ ├── .gitignore ├── LICENSE ├── README.md ├── build.gradle ├── gradle/ │ └── wrapper/ │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradle.properties ├── gradlew ├── gradlew.bat ├── library/ │ ├── .gitignore │ ├── build.gradle │ ├── proguard-rules.pro │ └── src/ │ ├── androidTest/ │ │ └── java/ │ │ └── com/ │ │ └── quincysx/ │ │ └── crypto/ │ │ └── ExampleInstrumentedTest.java │ ├── main/ │ │ ├── AndroidManifest.xml │ │ ├── java/ │ │ │ └── com/ │ │ │ └── quincysx/ │ │ │ └── crypto/ │ │ │ ├── CoinTypes.java │ │ │ ├── ECKeyPair.java │ │ │ ├── ECPublicKey.java │ │ │ ├── Key.java │ │ │ ├── SecureCharSequence.java │ │ │ ├── Transaction.java │ │ │ ├── TrulySecureRandom.java │ │ │ ├── bip32/ │ │ │ │ ├── ExtendedKey.java │ │ │ │ ├── Index.java │ │ │ │ └── ValidationException.java │ │ │ ├── bip38/ │ │ │ │ ├── Bip38.java │ │ │ │ └── Rijndael.java │ │ │ ├── bip39/ │ │ │ │ ├── ByteUtils.java │ │ │ │ ├── CharSequenceComparators.java │ │ │ │ ├── CharSequenceSplitter.java │ │ │ │ ├── MnemonicGenerator.java │ │ │ │ ├── MnemonicValidator.java │ │ │ │ ├── NFKDNormalizer.java │ │ │ │ ├── Normalization.java │ │ │ │ ├── PBKDF2WithHmacSHA512.java │ │ │ │ ├── RandomSeed.java │ │ │ │ ├── SeedCalculator.java │ │ │ │ ├── SeedCalculatorByWordListLookUp.java │ │ │ │ ├── SpongyCastlePBKDF2WithHmacSHA512.java │ │ │ │ ├── WordCount.java │ │ │ │ ├── WordList.java │ │ │ │ ├── WordListMapNormalization.java │ │ │ │ ├── exception/ │ │ │ │ │ └── MnemonicException.java │ │ │ │ ├── validation/ │ │ │ │ │ ├── InvalidChecksumException.java │ │ │ │ │ ├── InvalidWordCountException.java │ │ │ │ │ ├── UnexpectedWhiteSpaceException.java │ │ │ │ │ └── WordNotFoundException.java │ │ │ │ └── wordlists/ │ │ │ │ ├── English.java │ │ │ │ ├── French.java │ │ │ │ ├── Japanese.java │ │ │ │ └── Spanish.java │ │ │ ├── bip44/ │ │ │ │ ├── Account.java │ │ │ │ ├── AddressIndex.java │ │ │ │ ├── BIP44.java │ │ │ │ ├── Change.java │ │ │ │ ├── CoinPairDerive.java │ │ │ │ ├── CoinType.java │ │ │ │ ├── M.java │ │ │ │ └── Purpose.java │ │ │ ├── bitcoin/ │ │ │ │ ├── BTCTransaction.java │ │ │ │ ├── BitCoinECKeyPair.java │ │ │ │ ├── BitcoinException.java │ │ │ │ ├── BitcoinInputStream.java │ │ │ │ └── BitcoinOutputStream.java │ │ │ ├── eip55/ │ │ │ │ └── EthCheckAddress.java │ │ │ ├── eos/ │ │ │ │ └── EOSECKeyPair.java │ │ │ ├── ethereum/ │ │ │ │ ├── Bloom.java │ │ │ │ ├── ByteArrayWrapper.java │ │ │ │ ├── CallTransaction.java │ │ │ │ ├── ECDSASignature.java │ │ │ │ ├── EthECKeyPair.java │ │ │ │ ├── EthTransaction.java │ │ │ │ ├── config/ │ │ │ │ │ └── Constants.java │ │ │ │ ├── keystore/ │ │ │ │ │ ├── CipherException.java │ │ │ │ │ ├── KeyStore.java │ │ │ │ │ └── KeyStoreFile.java │ │ │ │ ├── rlp/ │ │ │ │ │ ├── CompactEncoder.java │ │ │ │ │ ├── DecodeResult.java │ │ │ │ │ ├── RLP.java │ │ │ │ │ ├── RLPElement.java │ │ │ │ │ ├── RLPItem.java │ │ │ │ │ ├── RLPList.java │ │ │ │ │ └── Value.java │ │ │ │ ├── solidity/ │ │ │ │ │ └── SolidityType.java │ │ │ │ ├── utils/ │ │ │ │ │ ├── ByteUtil.java │ │ │ │ │ └── FastByteComparisons.java │ │ │ │ └── vm/ │ │ │ │ ├── DataWord.java │ │ │ │ └── LogInfo.java │ │ │ ├── exception/ │ │ │ │ ├── CoinNotFindException.java │ │ │ │ └── NonSupportException.java │ │ │ └── utils/ │ │ │ ├── BTCUtils.java │ │ │ ├── Base58.java │ │ │ ├── Base58Check.java │ │ │ ├── Base64.java │ │ │ ├── HexUtils.java │ │ │ ├── HmacSha512.java │ │ │ ├── KECCAK256.java │ │ │ ├── RIPEMD160.java │ │ │ └── SHA256.java │ │ └── res/ │ │ └── values/ │ │ └── strings.xml │ └── test/ │ └── java/ │ └── com/ │ └── quincysx/ │ └── crypto/ │ ├── Bip32UnitTest.java │ ├── Bip39UnitTest.java │ ├── Bip44UnitTest.java │ ├── Eip55UnitTest.java │ ├── ExampleUnitTest.java │ └── HashUnitTest.java ├── sample/ │ ├── .gitignore │ ├── build.gradle │ ├── proguard-rules.pro │ └── src/ │ ├── androidTest/ │ │ └── java/ │ │ └── com/ │ │ └── quincysx/ │ │ └── crypto/ │ │ └── ExampleInstrumentedTest.java │ ├── main/ │ │ ├── AndroidManifest.xml │ │ ├── java/ │ │ │ └── com/ │ │ │ └── quincysx/ │ │ │ └── crypto/ │ │ │ └── smpale/ │ │ │ ├── Main1Activity.java │ │ │ └── MainActivity.java │ │ └── res/ │ │ ├── drawable/ │ │ │ └── ic_launcher_background.xml │ │ ├── drawable-v24/ │ │ │ └── ic_launcher_foreground.xml │ │ ├── layout/ │ │ │ └── activity_main.xml │ │ ├── mipmap-anydpi-v26/ │ │ │ ├── ic_launcher.xml │ │ │ └── ic_launcher_round.xml │ │ └── values/ │ │ ├── colors.xml │ │ ├── strings.xml │ │ └── styles.xml │ └── test/ │ └── java/ │ └── com/ │ └── quincysx/ │ └── crypto/ │ └── ExampleUnitTest.java └── settings.gradle ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitignore ================================================ *.iml .gradle /local.properties /.idea/workspace.xml /.idea/libraries .idea/ .DS_Store /build /captures .externalNativeBuild ================================================ FILE: LICENSE ================================================ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program 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 General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . ================================================ FILE: README.md ================================================ # BlockchainWallet-Crypto [![](https://jitpack.io/v/QuincySx/BlockchainWallet-Crypto.svg)](https://jitpack.io/#QuincySx/BlockchainWallet-Crypto) # 长时间不维护可移步 https://github.com/QuincySx/ChainWallet #### 简介 ##### 这个库到底能干什么 1. 生成比特币公私钥地址 2. 生成以太坊公私钥地址 3. 根据 UTXO 信息打包比特币交易 4. 根据 nonce 信息打包以太坊交易 5. 对比特币交易进行签名 6. 对以太坊交易进行签名 7. 支持 BIP39 助记词 8. 支持 BIP32 子私钥 9. 支持 BIP44 多币种管理 10. 支持 BIP38 加密私钥导入导出 11. 支持以太坊 keystore 导入导出 12. 生成以太坊调用智能合约的参数 13. 生成 EOS 公私钥 #### EOS 从助记词生成私钥 现在 EOS 从助记词生成私钥有两种方式 1. 12 个助记词之间用空格隔开拼接成字符串，然后 Hash 得到私钥 2. 采用 Bip44 标准的生成方案，EOS 的币种序号详见最下方⎡相关资料⎦中的⎡Bip44 注册币种列表⎦ 经过国内大部分钱包商议统一使用第二种方案解决 EOS 从助记词生成私钥的问题 #### 欢迎给位提设计上的 lssues 和 pr #### 引入项目 ``` allprojects { repositories { ... maven { url 'https://jitpack.io' } } } dependencies { implementation 'com.github.QuincySx:BlockchainWallet-Crypto:last-version' } ``` #### 使用说明 [简单使用说明](https://github.com/QuincySx/BlockchainWallet-Crypto/wiki) ## 相关资料 [Bip44 注册币种列表](https://github.com/satoshilabs/slips/blob/master/slip-0044.md) ## LICENSE [开源协议](LICENSE) ================================================ FILE: build.gradle ================================================ // Top-level build file where you can add configuration options common to all sub-projects/modules. buildscript { repositories { google() jcenter() } dependencies { classpath 'com.android.tools.build:gradle:3.1.2' // NOTE: Do not place your application dependencies here; they belong // in the individual module build.gradle files } } allprojects { repositories { google() jcenter() } } task clean(type: Delete) { delete rootProject.buildDir } ================================================ FILE: gradle/wrapper/gradle-wrapper.properties ================================================ #Tue Mar 27 20:02:31 CST 2018 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip ================================================ FILE: gradle.properties ================================================ # Project-wide Gradle settings. # IDE (e.g. Android Studio) users: # Gradle settings configured through the IDE *will override* # any settings specified in this file. # For more details on how to configure your build environment visit # http://www.gradle.org/docs/current/userguide/build_environment.html # Specifies the JVM arguments used for the daemon process. # The setting is particularly useful for tweaking memory settings. org.gradle.jvmargs=-Xmx1536m # When configured, Gradle will run in incubating parallel mode. # This option should only be used with decoupled projects. More details, visit # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects # org.gradle.parallel=true ================================================ FILE: gradlew ================================================ #!/usr/bin/env bash ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS="" APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn ( ) { echo "$*" } die ( ) { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; esac # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin, switch paths to Windows format before running java if $cygwin ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "$@" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=$((i+1)) done case $i in (0) set -- ;; (1) set -- "$args0" ;; (2) set -- "$args0" "$args1" ;; (3) set -- "$args0" "$args1" "$args2" ;; (4) set -- "$args0" "$args1" "$args2" "$args3" ;; (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules function splitJvmOpts() { JVM_OPTS=("$@") } eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME" exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@" ================================================ FILE: gradlew.bat ================================================ @if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS= set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto init echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto init echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :init @rem Get command-line arguments, handling Windowz variants if not "%OS%" == "Windows_NT" goto win9xME_args if "%@eval[2+2]" == "4" goto 4NT_args :win9xME_args @rem Slurp the command line arguments. set CMD_LINE_ARGS= set _SKIP=2 :win9xME_args_slurp if "x%~1" == "x" goto execute set CMD_LINE_ARGS=%* goto execute :4NT_args @rem Get arguments from the 4NT Shell from JP Software set CMD_LINE_ARGS=%$ :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS% :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega ================================================ FILE: library/.gitignore ================================================ /build ================================================ FILE: library/build.gradle ================================================ apply plugin: 'com.android.library' android { compileSdkVersion 27 defaultConfig { minSdkVersion 15 targetSdkVersion 27 versionCode 1 versionName "1.0" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } dependencies { api fileTree(dir: 'libs', include: ['*.jar']) api "com.cedarsoftware:java-util:1.8.0" api "com.fasterxml.jackson.core:jackson-databind:2.8.5" api 'com.madgag.spongycastle:core:1.58.0.0' api 'com.madgag.spongycastle:prov:1.58.0.0' api 'com.lambdaworks:scrypt:1.4.0' } ================================================ FILE: library/proguard-rules.pro ================================================ # Add project specific ProGuard rules here. # You can control the set of applied configuration files using the # proguardFiles setting in build.gradle. # # For more details, see # http://developer.android.com/guide/developing/tools/proguard.html # If your project uses WebView with JS, uncomment the following # and specify the fully qualified class name to the JavaScript interface # class: #-keepclassmembers class fqcn.of.javascript.interface.for.webview { # public *; #} # Uncomment this to preserve the line number information for # debugging stack traces. #-keepattributes SourceFile,LineNumberTable # If you keep the line number information, uncomment this to # hide the original source file name. #-renamesourcefileattribute SourceFile ================================================ FILE: library/src/androidTest/java/com/quincysx/crypto/ExampleInstrumentedTest.java ================================================ package com.quincysx.crypto; import android.content.Context; import android.support.test.InstrumentationRegistry; import android.support.test.runner.AndroidJUnit4; import org.junit.Test; import org.junit.runner.RunWith; import static org.junit.Assert.*; /** * Instrumented test, which will execute on an Android device. * * @see Testing documentation */ @RunWith(AndroidJUnit4.class) public class ExampleInstrumentedTest { @Test public void useAppContext() throws Exception { // Context of the app under test. Context appContext = InstrumentationRegistry.getTargetContext(); assertEquals("com.quincysx.crypto.test", appContext.getPackageName()); } } ================================================ FILE: library/src/main/AndroidManifest.xml ================================================ ================================================ FILE: library/src/main/java/com/quincysx/crypto/CoinTypes.java ================================================ package com.quincysx.crypto; import com.quincysx.crypto.exception.CoinNotFindException; /** * Created by q7728 on 2018/3/18. */ public enum CoinTypes { Bitcoin(0, "BTC"), BitcoinTest(1, "BTC"), Litecoin(2, "LTC"), Dogecoin(3, "DOGE"), Ethereum(60, "ETH"), EOS(194, "EOS"); private int coinType; private String coinName; CoinTypes(int i, String name) { coinType = i; coinName = name; } public int coinType() { return coinType; } public String coinName() { return coinName; } public static CoinTypes parseCoinType(int type) throws CoinNotFindException { for (CoinTypes e : CoinTypes.values()) { if (e.coinType == type) { return e; } } throw new CoinNotFindException("The currency is not supported for the time being"); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ECKeyPair.java ================================================ /* * Copyright 2013 bits of proof zrt. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.quincysx.crypto; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.utils.RIPEMD160; import org.spongycastle.asn1.ASN1InputStream; import org.spongycastle.asn1.DERInteger; import org.spongycastle.asn1.DLSequence; import org.spongycastle.asn1.sec.SECNamedCurves; import org.spongycastle.asn1.x9.X9ECParameters; import org.spongycastle.crypto.AsymmetricCipherKeyPair; import org.spongycastle.crypto.generators.ECKeyPairGenerator; import org.spongycastle.crypto.params.ECDomainParameters; import org.spongycastle.crypto.params.ECKeyGenerationParameters; import org.spongycastle.crypto.params.ECPrivateKeyParameters; import org.spongycastle.crypto.params.ECPublicKeyParameters; import org.spongycastle.crypto.signers.ECDSASigner; import org.spongycastle.math.ec.ECPoint; import org.spongycastle.util.Arrays; import java.io.IOException; import java.math.BigInteger; import java.security.SecureRandom; public class ECKeyPair implements Key { protected static final SecureRandom secureRandom = new SecureRandom(); protected static final X9ECParameters CURVE = SECNamedCurves.getByName("secp256k1"); protected static final ECDomainParameters domain = new ECDomainParameters(CURVE.getCurve(), CURVE.getG(), CURVE.getN(), CURVE.getH()); protected static final BigInteger LARGEST_PRIVATE_KEY = new BigInteger ("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16); protected BigInteger priv; protected byte[] pub; protected byte[] pubComp; protected boolean compressed; protected ECKeyPair() { } public ECKeyPair(byte[] p, boolean compressed) throws ValidationException { this(new BigInteger(1, p), compressed); if (!(p.length == 32 || p.length == 43 )) { throw new ValidationException("Invalid private key"); } } public ECKeyPair(BigInteger priv, boolean compressed) { this.priv = priv; this.compressed = compressed; ECPoint multiply = CURVE.getG().multiply(priv); this.pub = multiply.getEncoded(false); this.pubComp = multiply.getEncoded(true); } protected ECKeyPair(Key keyPair) { this.priv = new BigInteger(1, keyPair.getRawPrivateKey()); this.compressed = keyPair.isCompressed(); this.pub = Arrays.clone(keyPair.getRawPublicKey(false)); this.pubComp = Arrays.clone(keyPair.getRawPublicKey()); } @Override public boolean isCompressed() { return compressed; } @Override public ECKeyPair clone() throws CloneNotSupportedException { ECKeyPair c = (ECKeyPair) super.clone(); c.priv = new BigInteger(c.priv.toByteArray()); c.pub = Arrays.clone(pub); c.pubComp = Arrays.clone(pubComp); c.compressed = compressed; return c; } public static ECKeyPair createNew(boolean compressed) { ECKeyPairGenerator generator = new ECKeyPairGenerator(); ECKeyGenerationParameters keygenParams = new ECKeyGenerationParameters(domain, secureRandom); generator.init(keygenParams); AsymmetricCipherKeyPair keypair = generator.generateKeyPair(); ECPrivateKeyParameters privParams = (ECPrivateKeyParameters) keypair.getPrivate(); ECPublicKeyParameters pubParams = (ECPublicKeyParameters) keypair.getPublic(); ECKeyPair k = new ECKeyPair(); k.priv = privParams.getD(); k.compressed = compressed; ECPoint multiply = CURVE.getG().multiply(k.priv); k.pub = multiply.getEncoded(false); k.pubComp = multiply.getEncoded(true); return k; } public void setPublic(byte[] pub) throws ValidationException { throw new ValidationException("Can not set public key if private is present"); } @Override public byte[] getRawPrivateKey() { byte[] p = priv.toByteArray(); if (p.length != 32) { byte[] tmp = new byte[32]; System.arraycopy(p, Math.max(0, p.length - 32), tmp, Math.max(0, 32 - p.length), Math .min(32, p.length)); p = tmp; } return p; } @Override public byte[] getRawPublicKey(boolean isCompressed) { if (isCompressed) { return Arrays.clone(pubComp); } else { return Arrays.clone(pub); } } @Override public byte[] getRawPublicKey() { return getRawPublicKey(true); } @Override public byte[] getRawAddress() { return RIPEMD160.hash160(pubComp); } @Override public String getPrivateKey() { throw new RuntimeException("No formatted private Key"); } @Override public String getPublicKey() { throw new RuntimeException("No formatted public Key"); } @Override public String getAddress() { throw new RuntimeException("No formatted address"); } @Override public T sign(byte[] messageHash) throws ValidationException { throw new ValidationException("Please convert to ECKeyPair subclass signature"); } public static boolean verify(byte[] hash, byte[] signature, byte[] pub) { ASN1InputStream asn1 = new ASN1InputStream(signature); try { ECDSASigner signer = new ECDSASigner(); signer.init(false, new ECPublicKeyParameters(CURVE.getCurve().decodePoint(pub), domain)); DLSequence seq = (DLSequence) asn1.readObject(); BigInteger r = ((DERInteger) seq.getObjectAt(0)).getPositiveValue(); BigInteger s = ((DERInteger) seq.getObjectAt(1)).getPositiveValue(); return signer.verifySignature(hash, r, s); } catch (Exception e) { // threat format errors as invalid signatures return false; } finally { try { asn1.close(); } catch (IOException e) { } } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ECPublicKey.java ================================================ /* * Copyright 2013 bits of proof zrt. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.quincysx.crypto; import com.quincysx.crypto.utils.RIPEMD160; import org.spongycastle.util.Arrays; public class ECPublicKey implements Key { private byte[] pub; private boolean compressed; public ECPublicKey(byte[] pub, boolean compressed) { this.pub = pub; this.compressed = compressed; } @Override public boolean isCompressed() { return compressed; } public void setCompressed(boolean compressed) { this.compressed = compressed; } @Override public byte[] getRawPrivateKey() { throw new RuntimeException("Please use private key to sign signature"); } @Override public byte[] getRawPublicKey(boolean isCompressed) { if (!isCompressed) { throw new RuntimeException("No compressed public key"); } return Arrays.clone(pub); } @Override public byte[] getRawPublicKey() { return Arrays.clone(pub); } @Override public byte[] getRawAddress() { return RIPEMD160.hash160(pub); } @Override public String getPrivateKey() { throw new RuntimeException("Please use private key to sign signature"); } @Override public String getPublicKey() { throw new RuntimeException("No formatted public Key"); } @Override public String getAddress() { throw new RuntimeException("No formatted address"); } @Override public ECPublicKey clone() throws CloneNotSupportedException { ECPublicKey c = (ECPublicKey) super.clone(); c.pub = Arrays.clone(pub); return c; } @Override public T sign(byte[] messageHash) { throw new RuntimeException("Please use private key to sign signature"); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/Key.java ================================================ /* * Copyright 2013 bits of proof zrt. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.quincysx.crypto; import com.quincysx.crypto.bip32.ValidationException; public interface Key extends Cloneable { /** * 获取原生私钥 * * @return */ public byte[] getRawPrivateKey(); /** * 获取公钥 * * @param isCompressed 是否压缩 * @return 原生公钥 */ public byte[] getRawPublicKey(boolean isCompressed); /** * 获取原生压缩公钥 * * @return */ public byte[] getRawPublicKey(); /** * 获取地址 * * @return */ public byte[] getRawAddress(); /** * 获取格式化的私钥 * * @return */ public String getPrivateKey(); /** * 获取格式化的公钥 * * @return */ public String getPublicKey(); /** * 获取格式化的地址 * * @return */ public String getAddress(); /** * 获取判断公钥是否是压缩格式 * * @return */ public boolean isCompressed(); public Key clone() throws CloneNotSupportedException; public T sign(byte[] messageHash) throws ValidationException; } ================================================ FILE: library/src/main/java/com/quincysx/crypto/SecureCharSequence.java ================================================ package com.quincysx.crypto; import java.security.SecureRandom; import java.util.Arrays; /** * @author QuincySx * @date 2018/3/9 下午2:57 */ public class SecureCharSequence implements CharSequence { private char[] chars; public SecureCharSequence(CharSequence charSequence) { this(charSequence, 0, charSequence.length()); } public SecureCharSequence(char[] chars) { wipe(); this.chars = chars; } private SecureCharSequence(CharSequence charSequence, int start, int end) { // pulled from http://stackoverflow.com/a/15844273 wipe(); int length = end - start; chars = new char[length]; for (int i = start; i < end; i++) { chars[i - start] = charSequence.charAt(i); } } public void wipe() { if (chars != null) { Arrays.fill(chars, ' '); SecureRandom r = new SecureRandom(); byte[] bytes = new byte[chars.length]; r.nextBytes(bytes); for (int i = 0; i < chars.length; i++) { chars[i] = (char) bytes[i]; } Arrays.fill(chars, ' '); } } protected void finalize() { wipe(); } @Override public int length() { if (chars != null) { return chars.length; } return 0; } @Override public char charAt(int index) { if (chars != null) { return chars[index]; } return 0; } @Override public String toString() { return String.valueOf(this.chars); } @Override public boolean equals(Object o) { if (o instanceof SecureCharSequence) { return Arrays.equals(chars, ((SecureCharSequence) o).chars); } return false; } @Override public CharSequence subSequence(int start, int end) { SecureCharSequence s = new SecureCharSequence(this, start, end); return s; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/Transaction.java ================================================ package com.quincysx.crypto; import com.quincysx.crypto.bip32.ValidationException; /** * @author QuincySx * @date 2018/3/8 下午1:56 */ public interface Transaction { byte[] sign(ECKeyPair key) throws ValidationException; public byte[] getSignBytes(); /** * Eth 使用的方法 * * @return */ public byte[] getData(); } ================================================ FILE: library/src/main/java/com/quincysx/crypto/TrulySecureRandom.java ================================================ /* The MIT License (MIT) Copyright (c) 2013 Valentin Konovalov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/ package com.quincysx.crypto; import android.os.Build; import android.os.SystemClock; import android.util.Log; import com.quincysx.crypto.utils.HexUtils; import org.spongycastle.crypto.digests.SHA256Digest; import org.spongycastle.crypto.prng.DigestRandomGenerator; import org.spongycastle.crypto.prng.ThreadedSeedGenerator; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class TrulySecureRandom extends java.security.SecureRandom { private static final String TAG = "SecureRandom"; private final DigestRandomGenerator generator; private boolean initialized; public TrulySecureRandom() { generator = new DigestRandomGenerator(new SHA256Digest()); } public void addSeedMaterial(long seed) { generator.addSeedMaterial(seed); } private void addSeedMaterial(byte[] seed) { generator.addSeedMaterial(seed); } @Override public int nextInt() { byte[] buf = new byte[4]; nextBytes(buf); return ((buf[0] & 0xff) << 24) | ((buf[1] & 0xff) << 16) | ((buf[2] & 0xff) << 8) | (buf[3] & 0xff); } @Override public int nextInt(int n) { return Math.abs(nextInt()) % n; } @Override public synchronized void nextBytes(byte[] bytes) { if (!initialized) { long start = System.currentTimeMillis(); ThreadedSeedGenerator threadedSeedGenerator = new ThreadedSeedGenerator(); do { addSeedMaterial(threadedSeedGenerator.generateSeed(64, true)); try { Thread.sleep(1); } catch (InterruptedException ignored) { } addSeedMaterial(threadedSeedGenerator.generateSeed(32, false)); } while (Math.abs(System.currentTimeMillis() - start) < 1000); addSeedMaterial(System.nanoTime()); addSeedMaterial(System.currentTimeMillis()); addSeedMaterial(SystemClock.elapsedRealtime()); addSeedMaterial(SystemClock.currentThreadTimeMillis()); addSeedMaterial(new java.security.SecureRandom().generateSeed(128)); addSeedMaterial(("" + Build.DEVICE + Build.MODEL + Build.TIME + Build.VERSION.SDK_INT).getBytes()); ExecutorService executor = Executors.newSingleThreadExecutor(); try { Future future = executor.submit(new Runnable() { @Override public void run() { byte[] devRandomSeed = getDevRandomSeed(); if (devRandomSeed != null) { addSeedMaterial(devRandomSeed); } } }); future.get(3, TimeUnit.SECONDS); } catch (InterruptedException e) { Log.v(TAG, "/dev/random read interrupted"); } catch (ExecutionException e) { Log.e(TAG, "/dev/random read error"); } catch (TimeoutException e) { Log.w(TAG, "/dev/random read timeout"); } finally { executor.shutdownNow(); } initialized = true; } generator.nextBytes(bytes); } @Override public String getAlgorithm() { return "BouncyCastle"; } private byte[] getDevRandomSeed() { byte[] buf = null; File file = new File("/dev/random"); FileInputStream inputStream = null; try { inputStream = new FileInputStream(file); buf = new byte[16]; for (int i = 0; i < buf.length; i++) { int ch = inputStream.read(); if (ch == -1) { return null; } buf[i] = (byte) ch; } } catch (Exception ignored) { } finally { if (inputStream != null) { try { inputStream.close(); } catch (IOException ignored) { } } } return buf; } @Override public void setSeed(byte[] seed) { Log.w("SecureRandom", "setting seed " + HexUtils.toHex(seed) + " was ignored"); } @Override public void setSeed(long seed) { Log.w("SecureRandom", "setting seed " + seed + " was ignored"); } @Override public byte[] generateSeed(int numBytes) { throw new RuntimeException("not supported"); } @Override public boolean nextBoolean() { throw new RuntimeException("not supported"); } @Override public double nextDouble() { throw new RuntimeException("not supported"); } @Override public float nextFloat() { throw new RuntimeException("not supported"); } @Override public synchronized double nextGaussian() { throw new RuntimeException("not supported"); } @Override public long nextLong() { throw new RuntimeException("not supported"); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip32/ExtendedKey.java ================================================ /* * Copyright 2013 bits of proof zrt. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.quincysx.crypto.bip32; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.ECPublicKey; import com.quincysx.crypto.Key; import com.quincysx.crypto.utils.Base58Check; import org.spongycastle.asn1.sec.SECNamedCurves; import org.spongycastle.asn1.x9.X9ECParameters; import org.spongycastle.crypto.generators.SCrypt; import org.spongycastle.math.ec.ECPoint; import org.spongycastle.util.Arrays; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.math.BigInteger; import java.security.InvalidAlgorithmParameterException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.SecureRandom; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.Mac; import javax.crypto.NoSuchPaddingException; import javax.crypto.SecretKey; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; /** * Key Generator following BIP32 https://en.bitcoin.it/wiki/BIP_0032 */ public class ExtendedKey { private static final SecureRandom rnd = new SecureRandom(); private static final X9ECParameters curve = SECNamedCurves.getByName("secp256k1"); private final Key master; private final byte[] chainCode; private final int depth; private final int parent; private final int sequence; private static final byte[] BITCOIN_SEED = "Bitcoin seed".getBytes(); public static ExtendedKey createFromPassphrase(String passphrase, byte[] encrypted) throws ValidationException { try { byte[] key = SCrypt.generate(passphrase.getBytes("UTF-8"), BITCOIN_SEED, 16384, 8, 8, 32); SecretKeySpec keyspec = new SecretKeySpec(key, "AES"); if (encrypted.length == 32) { // asssume encrypted is seed Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding", "BC"); cipher.init(Cipher.DECRYPT_MODE, keyspec); return create(cipher.doFinal(encrypted)); } else { // assume encrypted serialization of a key Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC"); byte[] iv = Arrays.copyOfRange(encrypted, 0, 16); byte[] data = Arrays.copyOfRange(encrypted, 16, encrypted.length); cipher.init(Cipher.DECRYPT_MODE, keyspec, new IvParameterSpec(iv)); return ExtendedKey.parse(new String(cipher.doFinal(data))); } } catch (UnsupportedEncodingException e) { throw new ValidationException(e); } catch (IllegalBlockSizeException e) { throw new ValidationException(e); } catch (BadPaddingException e) { throw new ValidationException(e); } catch (InvalidKeyException e) { throw new ValidationException(e); } catch (NoSuchAlgorithmException e) { throw new ValidationException(e); } catch (NoSuchProviderException e) { throw new ValidationException(e); } catch (NoSuchPaddingException e) { throw new ValidationException(e); } catch (InvalidAlgorithmParameterException e) { throw new ValidationException(e); } } public byte[] encrypt(String passphrase, boolean production) throws ValidationException { try { byte[] key = SCrypt.generate(passphrase.getBytes("UTF-8"), BITCOIN_SEED, 16384, 8, 8, 32); SecretKeySpec keyspec = new SecretKeySpec(key, "AES"); Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC"); cipher.init(Cipher.ENCRYPT_MODE, keyspec); byte[] iv = cipher.getIV(); byte[] c = cipher.doFinal(serialize(production).getBytes()); byte[] result = new byte[iv.length + c.length]; System.arraycopy(iv, 0, result, 0, iv.length); System.arraycopy(c, 0, result, iv.length, c.length); return result; } catch (UnsupportedEncodingException | NoSuchAlgorithmException | NoSuchProviderException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) { throw new ValidationException(e); } } public static ExtendedKey create(byte[] seed) throws ValidationException { try { Mac mac = Mac.getInstance("HmacSHA512", "BC"); SecretKey seedkey = new SecretKeySpec(BITCOIN_SEED, "HmacSHA512"); mac.init(seedkey); byte[] lr = mac.doFinal(seed); byte[] l = Arrays.copyOfRange(lr, 0, 32); byte[] r = Arrays.copyOfRange(lr, 32, 64); BigInteger m = new BigInteger(1, l); if (m.compareTo(curve.getN()) >= 0) { throw new ValidationException("This is rather unlikely, but it did just happen"); } ECKeyPair keyPair = new ECKeyPair(l, true); return new ExtendedKey(keyPair, r, 0, 0, 0); } catch (NoSuchAlgorithmException e) { throw new ValidationException(e); } catch (NoSuchProviderException e) { throw new ValidationException(e); } catch (InvalidKeyException e) { throw new ValidationException(e); } } public static ExtendedKey createNew() { Key key = ECKeyPair.createNew(true); byte[] chainCode = new byte[32]; rnd.nextBytes(chainCode); return new ExtendedKey(key, chainCode, 0, 0, 0); } /** * @param bytes * @return * @throws ValidationException * @deprecated */ public static ExtendedKey parsePrivateKey(byte[] bytes) throws ValidationException { Key key = new ECKeyPair(bytes, true); byte[] chainCode = new byte[32]; rnd.nextBytes(chainCode); return new ExtendedKey(key, chainCode, 0, 0, 0); } public ExtendedKey(Key key, byte[] chainCode, int depth, int parent, int sequence) { this.master = key; this.chainCode = chainCode; this.parent = parent; this.depth = depth; this.sequence = sequence; } public Key getMaster() { return master; } public byte[] getChainCode() { return Arrays.clone(chainCode); } public int getDepth() { return depth; } public int getParent() { return parent; } public int getSequence() { return sequence; } public int getFingerPrint() { int fingerprint = 0; byte[] address = master.getRawAddress(); for (int i = 0; i < 4; ++i) { fingerprint <<= 8; fingerprint |= address[i] & 0xff; } return fingerprint; } public Key getKey(int sequence) throws ValidationException { return generateKey(sequence).getMaster(); } public ExtendedKey getChild(int sequence) throws ValidationException { ExtendedKey sub = generateKey(sequence); return new ExtendedKey(sub.getMaster(), sub.getChainCode(), sub.getDepth() + 1, getFingerPrint(), sequence); } public ExtendedKey getReadOnly() { return new ExtendedKey(new ECPublicKey(master.getRawPublicKey(), true), chainCode, depth, parent, sequence); } public boolean isReadOnly() { return master.getRawPrivateKey() == null; } private ExtendedKey generateKey(int sequence) throws ValidationException { try { if ((sequence & 0x80000000) != 0 && master.getRawPrivateKey() == null) { throw new ValidationException("need private key for private generation"); } Mac mac = Mac.getInstance("HmacSHA512", "BC"); SecretKey key = new SecretKeySpec(chainCode, "HmacSHA512"); mac.init(key); byte[] extended; byte[] pub = master.getRawPublicKey(); if ((sequence & 0x80000000) == 0) { extended = new byte[pub.length + 4]; System.arraycopy(pub, 0, extended, 0, pub.length); extended[pub.length] = (byte) ((sequence >>> 24) & 0xff); extended[pub.length + 1] = (byte) ((sequence >>> 16) & 0xff); extended[pub.length + 2] = (byte) ((sequence >>> 8) & 0xff); extended[pub.length + 3] = (byte) (sequence & 0xff); } else { byte[] priv = master.getRawPrivateKey(); extended = new byte[priv.length + 5]; System.arraycopy(priv, 0, extended, 1, priv.length); extended[priv.length + 1] = (byte) ((sequence >>> 24) & 0xff); extended[priv.length + 2] = (byte) ((sequence >>> 16) & 0xff); extended[priv.length + 3] = (byte) ((sequence >>> 8) & 0xff); extended[priv.length + 4] = (byte) (sequence & 0xff); } byte[] lr = mac.doFinal(extended); byte[] l = Arrays.copyOfRange(lr, 0, 32); byte[] r = Arrays.copyOfRange(lr, 32, 64); BigInteger m = new BigInteger(1, l); if (m.compareTo(curve.getN()) >= 0) { throw new ValidationException("This is rather unlikely, but it did just happen"); } if (master.getRawPrivateKey() != null) { BigInteger k = m.add(new BigInteger(1, master.getRawPrivateKey())).mod(curve.getN ()); if (k.equals(BigInteger.ZERO)) { throw new ValidationException("This is rather unlikely, but it did just " + "happen"); } return new ExtendedKey(new ECKeyPair(k, true), r, depth, parent, sequence); } else { ECPoint q = curve.getG().multiply(m).add(curve.getCurve().decodePoint(pub)); if (q.isInfinity()) { throw new ValidationException("This is rather unlikely, but it did just " + "happen"); } pub = new ECPoint.Fp(curve.getCurve(), q.getX(), q.getY(), true).getEncoded(); return new ExtendedKey(new ECPublicKey(pub, true), r, depth, parent, sequence); } } catch (NoSuchAlgorithmException e) { throw new ValidationException(e); } catch (NoSuchProviderException e) { throw new ValidationException(e); } catch (InvalidKeyException e) { throw new ValidationException(e); } } private static final byte[] xprv = new byte[]{0x04, (byte) 0x88, (byte) 0xAD, (byte) 0xE4}; private static final byte[] xpub = new byte[]{0x04, (byte) 0x88, (byte) 0xB2, (byte) 0x1E}; private static final byte[] tprv = new byte[]{0x04, (byte) 0x35, (byte) 0x83, (byte) 0x94}; private static final byte[] tpub = new byte[]{0x04, (byte) 0x35, (byte) 0x87, (byte) 0xCF}; public String serialize(boolean production) { ByteArrayOutputStream out = new ByteArrayOutputStream(); try { if (master.getRawPrivateKey() != null) { if (production) { out.write(xprv); } else { out.write(tprv); } } else { if (production) { out.write(xpub); } else { out.write(tpub); } } out.write(depth & 0xff); out.write((parent >>> 24) & 0xff); out.write((parent >>> 16) & 0xff); out.write((parent >>> 8) & 0xff); out.write(parent & 0xff); out.write((sequence >>> 24) & 0xff); out.write((sequence >>> 16) & 0xff); out.write((sequence >>> 8) & 0xff); out.write(sequence & 0xff); out.write(chainCode); if (master.getRawPrivateKey() != null) { out.write(0x00); out.write(master.getRawPrivateKey()); } else { out.write(master.getRawPublicKey()); } } catch (IOException e) { } return Base58Check.bytesToBase58(out.toByteArray()); } public static ExtendedKey parse(String serialized) throws ValidationException { byte[] data = Base58Check.base58ToBytes(serialized); if (data.length != 78) { throw new ValidationException("invalid extended key"); } byte[] type = Arrays.copyOf(data, 4); boolean hasPrivate; if (Arrays.areEqual(type, xprv) || Arrays.areEqual(type, tprv)) { hasPrivate = true; } else if (Arrays.areEqual(type, xpub) || Arrays.areEqual(type, tpub)) { hasPrivate = false; } else { throw new ValidationException("invalid magic number for an extended key"); } int depth = data[4] & 0xff; int parent = data[5] & 0xff; parent <<= 8; parent |= data[6] & 0xff; parent <<= 8; parent |= data[7] & 0xff; parent <<= 8; parent |= data[8] & 0xff; int sequence = data[9] & 0xff; sequence <<= 8; sequence |= data[10] & 0xff; sequence <<= 8; sequence |= data[11] & 0xff; sequence <<= 8; sequence |= data[12] & 0xff; byte[] chainCode = Arrays.copyOfRange(data, 13, 13 + 32); byte[] pubOrPriv = Arrays.copyOfRange(data, 13 + 32, data.length); Key key; if (hasPrivate) { key = new ECKeyPair(new BigInteger(1, pubOrPriv), true); } else { key = new ECPublicKey(pubOrPriv, true); } return new ExtendedKey(key, chainCode, depth, parent, sequence); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip32/Index.java ================================================ package com.quincysx.crypto.bip32; /** * @author QuincySx * @date 2018/3/5 下午4:29 */ public final class Index { Index() { } public static int hard(final int index) { return index | 0x80000000; } public static boolean isHardened(final int i) { return (i & 0x80000000) != 0; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip32/ValidationException.java ================================================ /* * Copyright 2013 bits of proof zrt. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.quincysx.crypto.bip32; public class ValidationException extends Exception { private static final long serialVersionUID = 1L; public ValidationException(Throwable cause) { super (cause); } public ValidationException(String message, Throwable cause) { super (message, cause); } public ValidationException(String message) { super (message); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip38/Bip38.java ================================================ package com.quincysx.crypto.bip38; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.bitcoin.BitCoinECKeyPair; import com.quincysx.crypto.utils.Base58; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.SHA256; import org.spongycastle.crypto.generators.SCrypt; import java.math.BigInteger; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.charset.Charset; import java.util.Arrays; /** * @author QuincySx * @date 2018/3/8 下午2:41 */ public class Bip38 { //官方推荐参数 性能差的手机耗时特别长 private static final int SCRYPT_N = 16384; private static final int SCRYPT_R = 8; private static final int SCRYPT_P = 8; //性能差的手机也秒出，安全性差 // private static final int SCRYPT_N = 1024; // private static final int SCRYPT_R = 1; // private static final int SCRYPT_P = 1; private static final int SCRYPT_LENGTH = 64; private static final BigInteger n = new BigInteger(1, HexUtils.fromHex("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141")); /** * Encrypt a SIPA formatted private key with a passphrase using BIP38. *

* This is a helper function that does everything in one go. You can call the * individual functions if you wish to separate it into more phases. * * @throws InterruptedException */ public static String encryptNoEcMultiply(CharSequence passphrase, String base58EncodedPrivateKey) throws ValidationException, InterruptedException { byte[] tmp = Base58.decode(base58EncodedPrivateKey); int version = tmp[0] & 0xFF; byte[] bytes = new byte[tmp.length - 4 - 1]; System.arraycopy(tmp, 1, bytes, 0, bytes.length); boolean compressed = true; if (bytes.length == 33 && bytes[32] == 1) { compressed = true; bytes = java.util.Arrays.copyOf(bytes, 32); // Chop off the additional marker byte. } else if (bytes.length == 32) { compressed = false; } boolean testNet = false; if (version == BitCoinECKeyPair.TEST_NET_PRIVATE_KEY_PREFIX) { testNet = true; } else if (version == BitCoinECKeyPair.MAIN_NET_PRIVATE_KEY_PREFIX) { testNet = false; } Arrays.fill(tmp, (byte) 0); BitCoinECKeyPair bitCoinECKeyPair = new BitCoinECKeyPair(bytes, testNet, compressed); byte[] salt = Bip38.calculateScryptSalt(bitCoinECKeyPair.getAddress()); byte[] stretchedKeyMaterial = bip38Stretch1(passphrase, salt, SCRYPT_LENGTH); return encryptNoEcMultiply(stretchedKeyMaterial, bitCoinECKeyPair, salt); } /** * Perform BIP38 compatible password stretching on a password to derive the * BIP38 key material * * @throws InterruptedException */ public static byte[] bip38Stretch1(CharSequence passphrase, byte[] salt, int outputSize) throws InterruptedException { byte[] passwordBytes = null; byte[] derived; try { passwordBytes = convertToByteArray(passphrase); derived = SCrypt.generate(passwordBytes, salt, SCRYPT_N, SCRYPT_R, SCRYPT_P, outputSize ); return derived; } finally { // Zero the password bytes. if (passwordBytes != null) { java.util.Arrays.fill(passwordBytes, (byte) 0); } } } private static byte[] convertToByteArray(CharSequence charSequence) { if (charSequence == null) { throw new RuntimeException("charSequence not NULL"); } ByteBuffer bb = Charset.forName("UTF-8").encode(CharBuffer.wrap(charSequence)); byte[] result = new byte[bb.remaining()]; bb.get(result); bb.clear(); byte[] clearTest = new byte[bb.remaining()]; java.util.Arrays.fill(clearTest, (byte) 0); bb.put(clearTest); return result; } public static String encryptNoEcMultiply(byte[] stretcedKeyMaterial, BitCoinECKeyPair key, byte[] salt) { int checksumLength = 4; byte[] encoded = new byte[39 + checksumLength]; int index = 0; encoded[index++] = (byte) 0x01; encoded[index++] = (byte) 0x42; byte non_EC_multiplied = (byte) 0xC0; byte compressedPublicKey = key.isCompressed() ? (byte) 0x20 : (byte) 0; encoded[index++] = (byte) (non_EC_multiplied | compressedPublicKey); // Salt System.arraycopy(salt, 0, encoded, index, salt.length); index += salt.length; // Derive Keys byte[] derivedHalf1 = new byte[32]; System.arraycopy(stretcedKeyMaterial, 0, derivedHalf1, 0, 32); byte[] derivedHalf2 = new byte[32]; System.arraycopy(stretcedKeyMaterial, 32, derivedHalf2, 0, 32); // Initialize AES key Rijndael aes = new Rijndael(); aes.makeKey(derivedHalf2, 256); // Get private key bytes byte[] complete = key.getRawPrivateKey(); // Insert first encrypted key part byte[] toEncryptPart1 = new byte[16]; for (int i = 0; i < 16; i++) { toEncryptPart1[i] = (byte) ((((int) complete[i]) & 0xFF) ^ (((int) derivedHalf1[i]) & 0xFF)); } byte[] encryptedHalf1 = new byte[16]; aes.encrypt(toEncryptPart1, encryptedHalf1); System.arraycopy(encryptedHalf1, 0, encoded, index, encryptedHalf1.length); index += encryptedHalf1.length; // Insert second encrypted key part byte[] toEncryptPart2 = new byte[16]; for (int i = 0; i < 16; i++) { toEncryptPart2[i] = (byte) ((((int) complete[16 + i]) & 0xFF) ^ (((int) derivedHalf1[16 + i]) & 0xFF)); } byte[] encryptedHalf2 = new byte[16]; aes.encrypt(toEncryptPart2, encryptedHalf2); System.arraycopy(encryptedHalf2, 0, encoded, index, encryptedHalf2.length); index += encryptedHalf2.length; // Checksum byte[] checkSum = SHA256.doubleSha256(encoded, 0, 39); byte[] start = new byte[4]; System.arraycopy(checkSum, 0, start, 0, 4); System.arraycopy(start, 0, encoded, 39, checksumLength); // Base58 encode return Base58.encode(encoded); } public static boolean isBip38PrivateKey(String bip38PrivateKey) { return parseBip38PrivateKey(bip38PrivateKey) != null; } public static class Bip38PrivateKey { public boolean ecMultiply; public boolean compressed; public boolean lotSequence; public byte[] salt; public byte[] data; public Bip38PrivateKey(boolean ecMultiply, boolean compressed, boolean lotSequence, byte[] salt, byte[] data) { this.ecMultiply = ecMultiply; this.compressed = compressed; this.lotSequence = lotSequence; this.salt = salt; this.data = data; } } public static Bip38PrivateKey parseBip38PrivateKey(String bip38PrivateKey) { // Decode Base 58 byte[] decoded = Base58.decode(bip38PrivateKey); if (decoded == null) { return null; } //Validate length if (!(decoded.length == 39 || decoded.length == 43)) { return null; } int index = 0; // Validate BIP 38 prefix if (decoded[index++] != (byte) 0x01) { return null; } boolean ecMultiply; if (decoded[index] == (byte) 0x42) { ecMultiply = false; } else if (decoded[index] == (byte) 0x43) { ecMultiply = true; } else { return null; } index++; // Validate flags and determine whether we have a compressed key int flags = ((int) decoded[index++]) & 0x00ff; boolean lotSequence; if (ecMultiply) { if ((flags | 0x0024) != 0x24) { // Only bit 3 and 6 can be set for EC-multiply keys return null; } lotSequence = (flags & 0x0004) == 0 ? false : true; } else { if ((flags | 0x00E0) != 0xE0) { // Only bit 6 7 and 8 can be set for non-EC-multiply keys return null; } if ((flags & 0x00c0) != 0x00c0) { // Upper two bits must be set for non-EC-multiplied key return null; } lotSequence = false; } boolean compressed = (flags & 0x0020) == 0 ? false : true; // Fetch salt byte[] salt = new byte[4]; salt[0] = decoded[index++]; salt[1] = decoded[index++]; salt[2] = decoded[index++]; salt[3] = decoded[index++]; // Fetch data byte[] data = new byte[32]; System.arraycopy(decoded, index, data, 0, data.length); index += data.length; return new Bip38PrivateKey(ecMultiply, compressed, lotSequence, salt, data); } /** * 可能为 Null ，Null 代表密码不正确 */ public static BitCoinECKeyPair decrypt(String bip38PrivateKeyString, CharSequence passphrase) throws InterruptedException, ValidationException { Bip38PrivateKey bip38Key = parseBip38PrivateKey(bip38PrivateKeyString); if (bip38Key == null) { return null; } if (bip38Key.ecMultiply) { return decryptEcMultiply(bip38Key, passphrase); } else { byte[] stretcedKeyMaterial = bip38Stretch1(passphrase, bip38Key.salt, SCRYPT_LENGTH); return decryptNoEcMultiply(bip38Key, stretcedKeyMaterial); } } public static BitCoinECKeyPair decryptEcMultiply(Bip38PrivateKey bip38Key, CharSequence passphrase ) throws InterruptedException, ValidationException { // Get 8 byte Owner Salt byte[] ownerEntropy = new byte[8]; System.arraycopy(bip38Key.data, 0, ownerEntropy, 0, 8); byte[] ownerSalt = ownerEntropy; if (bip38Key.lotSequence) { ownerSalt = new byte[4]; System.arraycopy(ownerEntropy, 0, ownerSalt, 0, 4); } // Stretch to get Pass Factor byte[] passFactor = bip38Stretch1(passphrase, ownerSalt, 32); if (bip38Key.lotSequence) { byte[] tmp = new byte[40]; System.arraycopy(passFactor, 0, tmp, 0, 32); System.arraycopy(ownerEntropy, 0, tmp, 32, 8); //we convert to byte[] here since this can be a sha256 or Scrypt result. // might make sense to introduce a 32 byte scrypt type passFactor = SHA256.doubleSha256(tmp); } // Determine Pass Point BitCoinECKeyPair bitCoinECKeyPair = new BitCoinECKeyPair(passFactor, false, bip38Key.compressed); byte[] passPoint = bitCoinECKeyPair.getRawPublicKey(); // Get 8 byte encrypted part 1, only first half of encrypted part 1 // (the rest is encrypted within encryptedpart2) byte[] encryptedPart1 = new byte[16]; System.arraycopy(bip38Key.data, 8, encryptedPart1, 0, 8); // Get 16 byte encrypted part 2 byte[] encryptedPart2 = new byte[16]; System.arraycopy(bip38Key.data, 16, encryptedPart2, 0, 16); // Second stretch to derive decryption key byte[] saltPlusOwnerSalt = new byte[12]; System.arraycopy(bip38Key.salt, 0, saltPlusOwnerSalt, 0, 4); System.arraycopy(ownerEntropy, 0, saltPlusOwnerSalt, 4, 8); // byte[] derived = SCrypt.generate(passPoint, saltPlusOwnerSalt, 1024, 1, 1, 64); byte[] derived = SCrypt.generate(passPoint, saltPlusOwnerSalt, SCRYPT_N, SCRYPT_R, SCRYPT_P, SCRYPT_LENGTH); byte[] derivedQuater1 = new byte[16]; System.arraycopy(derived, 0, derivedQuater1, 0, 16); byte[] derivedQuater2 = new byte[16]; System.arraycopy(derived, 16, derivedQuater2, 0, 16); byte[] derivedHalf2 = new byte[32]; System.arraycopy(derived, 32, derivedHalf2, 0, 32); Rijndael aes = new Rijndael(); aes.makeKey(derivedHalf2, 256); byte[] unencryptedPart2 = new byte[16]; aes.decrypt(encryptedPart2, unencryptedPart2); xorBytes(derivedQuater2, unencryptedPart2); // Get second half of encrypted half 1 System.arraycopy(unencryptedPart2, 0, encryptedPart1, 8, 8); // Decrypt part 1 byte[] unencryptedPart1 = new byte[16]; aes.decrypt(encryptedPart1, unencryptedPart1); xorBytes(derivedQuater1, unencryptedPart1); // Recover seedB byte[] seedB = new byte[24]; System.arraycopy(unencryptedPart1, 0, seedB, 0, 16); System.arraycopy(unencryptedPart2, 8, seedB, 16, 8); // Generate factorB byte[] factorB = SHA256.doubleSha256(seedB); BigInteger privateKey = new BigInteger(1, passFactor).multiply(new BigInteger(1, factorB).mod(n)); byte[] keyBytes = new byte[32]; byte[] bytes = privateKey.toByteArray(); if (bytes.length <= keyBytes.length) { System.arraycopy(bytes, 0, keyBytes, keyBytes.length - bytes.length, bytes.length); } else { assert bytes.length == 33 && bytes[0] == 0; System.arraycopy(bytes, 1, keyBytes, 0, bytes.length - 1); } BitCoinECKeyPair ecKeyPair = verify(keyBytes, bip38Key.salt, false, bip38Key.compressed); if (ecKeyPair == null) { return verify(keyBytes, bip38Key.salt, true, bip38Key.compressed); } return ecKeyPair; } public static BitCoinECKeyPair decryptNoEcMultiply(Bip38PrivateKey bip38Key, byte[] stretcedKeyMaterial) throws ValidationException { // Derive Keys byte[] derivedHalf1 = new byte[32]; System.arraycopy(stretcedKeyMaterial, 0, derivedHalf1, 0, 32); byte[] derivedHalf2 = new byte[32]; System.arraycopy(stretcedKeyMaterial, 32, derivedHalf2, 0, 32); // Initialize AES key Rijndael aes = new Rijndael(); aes.makeKey(derivedHalf2, 256); // Fetch first encrypted half byte[] encryptedHalf1 = new byte[16]; System.arraycopy(bip38Key.data, 0, encryptedHalf1, 0, encryptedHalf1.length); // Fetch second encrypted half byte[] encryptedHalf2 = new byte[16]; System.arraycopy(bip38Key.data, 16, encryptedHalf2, 0, encryptedHalf2.length); byte[] decryptedHalf1 = new byte[16]; aes.decrypt(encryptedHalf1, decryptedHalf1); byte[] decryptedHalf2 = new byte[16]; aes.decrypt(encryptedHalf2, decryptedHalf2); byte[] complete = new byte[32]; for (int i = 0; i < 16; i++) { complete[i] = (byte) ((((int) decryptedHalf1[i]) & 0xFF) ^ (((int) derivedHalf1[i]) & 0xFF)); complete[i + 16] = (byte) ((((int) decryptedHalf2[i]) & 0xFF) ^ (((int) derivedHalf1[i + 16]) & 0xFF)); } BitCoinECKeyPair bitCoinECKeyPair = verify(complete, bip38Key.salt, false, bip38Key.compressed); if (bitCoinECKeyPair == null) { return verify(complete, bip38Key.salt, true, bip38Key.compressed); } return bitCoinECKeyPair; } private static BitCoinECKeyPair verify(byte[] complete, byte[] salt, boolean testNet, boolean compress) throws ValidationException { BitCoinECKeyPair bitCoinECKeyPair = new BitCoinECKeyPair(complete, testNet, compress); byte[] newSalt = calculateScryptSalt(bitCoinECKeyPair.getAddress()); if (!java.util.Arrays.equals(salt, newSalt)) { // The passphrase is either invalid or we are on the wrong network return null; } return bitCoinECKeyPair; } public static byte[] calculateScryptSalt(String address) { byte[] hash = SHA256.doubleSha256(address.getBytes()); byte[] ret = new byte[4]; System.arraycopy(hash, 0, ret, 0, 4); return ret; } private static void xorBytes(byte[] toApply, byte[] target) { if (toApply.length != target.length) { throw new RuntimeException(); } for (int i = 0; i < toApply.length; i++) { target[i] = (byte) (target[i] ^ toApply[i]); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip38/Rijndael.java ================================================ package com.quincysx.crypto.bip38; /** * @author QuincySx * @date 2018/3/9 下午2:09 */ public final class Rijndael { public Rijndael() { } /** * Flag to setup the encryption key schedule. */ public static final int DIR_ENCRYPT = 1; /** * Flag to setup the decryption key schedule. */ public static final int DIR_DECRYPT = 2; /** * Flag to setup both key schedules (encryption/decryption). */ public static final int DIR_BOTH = (DIR_ENCRYPT | DIR_DECRYPT); /** * AES block size in bits * (N.B. the Rijndael algorithm itself allows for other sizes). */ public static final int BLOCK_BITS = 128; /** * AES block size in bytes * (N.B. the Rijndael algorithm itself allows for other sizes). */ public static final int BLOCK_SIZE = (BLOCK_BITS >>> 3); /** * Substitution table (S-box). */ private static final String SS = "\u637C\u777B\uF26B\u6FC5\u3001\u672B\uFED7\uAB76" + "\uCA82\uC97D\uFA59\u47F0\uADD4\uA2AF\u9CA4\u72C0" + "\uB7FD\u9326\u363F\uF7CC\u34A5\uE5F1\u71D8\u3115" + "\u04C7\u23C3\u1896\u059A\u0712\u80E2\uEB27\uB275" + "\u0983\u2C1A\u1B6E\u5AA0\u523B\uD6B3\u29E3\u2F84" + "\u53D1\u00ED\u20FC\uB15B\u6ACB\uBE39\u4A4C\u58CF" + "\uD0EF\uAAFB\u434D\u3385\u45F9\u027F\u503C\u9FA8" + "\u51A3\u408F\u929D\u38F5\uBCB6\uDA21\u10FF\uF3D2" + "\uCD0C\u13EC\u5F97\u4417\uC4A7\u7E3D\u645D\u1973" + "\u6081\u4FDC\u222A\u9088\u46EE\uB814\uDE5E\u0BDB" + "\uE032\u3A0A\u4906\u245C\uC2D3\uAC62\u9195\uE479" + "\uE7C8\u376D\u8DD5\u4EA9\u6C56\uF4EA\u657A\uAE08" + "\uBA78\u252E\u1CA6\uB4C6\uE8DD\u741F\u4BBD\u8B8A" + "\u703E\uB566\u4803\uF60E\u6135\u57B9\u86C1\u1D9E" + "\uE1F8\u9811\u69D9\u8E94\u9B1E\u87E9\uCE55\u28DF" + "\u8CA1\u890D\uBFE6\u4268\u4199\u2D0F\uB054\uBB16"; private static final byte[] Se = new byte[256]; private static final int[] Te0 = new int[256], Te1 = new int[256], Te2 = new int[256], Te3 = new int[256]; private static final byte[] Sd = new byte[256]; private static final int[] Td0 = new int[256], Td1 = new int[256], Td2 = new int[256], Td3 = new int[256]; /** * Round constants */ private static final int[] rcon = new int[10]; /* for 128-bit blocks, Rijndael never uses more than 10 rcon values */ /** * Number of rounds (depends on key size). */ private int Nr = 0; private int Nk = 0; private int Nw = 0; /** * Encryption key schedule */ private int rek[] = null; /** * Decryption key schedule */ private int rdk[] = null; static { /* Te0[x] = Se[x].[02, 01, 01, 03]; Te1[x] = Se[x].[03, 02, 01, 01]; Te2[x] = Se[x].[01, 03, 02, 01]; Te3[x] = Se[x].[01, 01, 03, 02]; Td0[x] = Sd[x].[0e, 09, 0d, 0b]; Td1[x] = Sd[x].[0b, 0e, 09, 0d]; Td2[x] = Sd[x].[0d, 0b, 0e, 09]; Td3[x] = Sd[x].[09, 0d, 0b, 0e]; */ int ROOT = 0x11B; int s1, s2, s3, i1, i2, i4, i8, i9, ib, id, ie, t; for (i1 = 0; i1 < 256; i1++) { char c = SS.charAt(i1 >>> 1); s1 = (byte) ((i1 & 1) == 0 ? c >>> 8 : c) & 0xff; s2 = s1 << 1; if (s2 >= 0x100) { s2 ^= ROOT; } s3 = s2 ^ s1; i2 = i1 << 1; if (i2 >= 0x100) { i2 ^= ROOT; } i4 = i2 << 1; if (i4 >= 0x100) { i4 ^= ROOT; } i8 = i4 << 1; if (i8 >= 0x100) { i8 ^= ROOT; } i9 = i8 ^ i1; ib = i9 ^ i2; id = i9 ^ i4; ie = i8 ^ i4 ^ i2; Se[i1] = (byte) s1; Te0[i1] = t = (s2 << 24) | (s1 << 16) | (s1 << 8) | s3; Te1[i1] = (t >>> 8) | (t << 24); Te2[i1] = (t >>> 16) | (t << 16); Te3[i1] = (t >>> 24) | (t << 8); Sd[s1] = (byte) i1; Td0[s1] = t = (ie << 24) | (i9 << 16) | (id << 8) | ib; Td1[s1] = (t >>> 8) | (t << 24); Td2[s1] = (t >>> 16) | (t << 16); Td3[s1] = (t >>> 24) | (t << 8); } /* * round constants */ int r = 1; rcon[0] = r << 24; for (int i = 1; i < 10; i++) { r <<= 1; if (r >= 0x100) { r ^= ROOT; } rcon[i] = r << 24; } } /** * Expand a cipher key into a full encryption key schedule. * * @param cipherKey the cipher key (128, 192, or 256 bits). */ private void expandKey(byte[] cipherKey) { int temp, r = 0; for (int i = 0, k = 0; i < Nk; i++, k += 4) { rek[i] = ((cipherKey[k]) << 24) | ((cipherKey[k + 1] & 0xff) << 16) | ((cipherKey[k + 2] & 0xff) << 8) | ((cipherKey[k + 3] & 0xff)); } for (int i = Nk, n = 0; i < Nw; i++, n--) { temp = rek[i - 1]; if (n == 0) { n = Nk; temp = ((Se[(temp >>> 16) & 0xff]) << 24) | ((Se[(temp >>> 8) & 0xff] & 0xff) << 16) | ((Se[(temp) & 0xff] & 0xff) << 8) | ((Se[(temp >>> 24)] & 0xff)); temp ^= rcon[r++]; } else if (Nk == 8 && n == 4) { temp = ((Se[(temp >>> 24)]) << 24) | ((Se[(temp >>> 16) & 0xff] & 0xff) << 16) | ((Se[(temp >>> 8) & 0xff] & 0xff) << 8) | ((Se[(temp) & 0xff] & 0xff)); } rek[i] = rek[i - Nk] ^ temp; } temp = 0; } /* * Faster implementation of the key expansion * (only worthwhile in Rijndael is used in a hashing function mode). */ /* private void expandKey(byte[] cipherKey) { int keyOffset = 0; int i = 0; int temp; rek[0] = (cipherKey[ 0] ) << 24 | (cipherKey[ 1] & 0xff) << 16 | (cipherKey[ 2] & 0xff) << 8 | (cipherKey[ 3] & 0xff); rek[1] = (cipherKey[ 4] ) << 24 | (cipherKey[ 5] & 0xff) << 16 | (cipherKey[ 6] & 0xff) << 8 | (cipherKey[ 7] & 0xff); rek[2] = (cipherKey[ 8] ) << 24 | (cipherKey[ 9] & 0xff) << 16 | (cipherKey[10] & 0xff) << 8 | (cipherKey[11] & 0xff); rek[3] = (cipherKey[12] ) << 24 | (cipherKey[13] & 0xff) << 16 | (cipherKey[14] & 0xff) << 8 | (cipherKey[15] & 0xff); if (Nk == 4) { for (;;) { temp = rek[keyOffset + 3]; rek[keyOffset + 4] = rek[keyOffset] ^ ((Se[(temp >>> 16) & 0xff] ) << 24) ^ ((Se[(temp >>> 8) & 0xff] & 0xff) << 16) ^ ((Se[(temp ) & 0xff] & 0xff) << 8) ^ ((Se[(temp >>> 24) ] & 0xff) ) ^ rcon[i]; rek[keyOffset + 5] = rek[keyOffset + 1] ^ rek[keyOffset + 4]; rek[keyOffset + 6] = rek[keyOffset + 2] ^ rek[keyOffset + 5]; rek[keyOffset + 7] = rek[keyOffset + 3] ^ rek[keyOffset + 6]; if (++i == 10) { return; } keyOffset += 4; } } rek[keyOffset + 4] = (cipherKey[16] ) << 24 | (cipherKey[17] & 0xff) << 16 | (cipherKey[18] & 0xff) << 8 | (cipherKey[19] & 0xff); rek[keyOffset + 5] = (cipherKey[20] ) << 24 | (cipherKey[21] & 0xff) << 16 | (cipherKey[22] & 0xff) << 8 | (cipherKey[23] & 0xff); if (Nk == 6) { for (;;) { temp = rek[keyOffset + 5]; rek[keyOffset + 6] = rek[keyOffset] ^ ((Se[(temp >>> 16) & 0xff] ) << 24) ^ ((Se[(temp >>> 8) & 0xff] & 0xff) << 16) ^ ((Se[(temp ) & 0xff] & 0xff) << 8) ^ ((Se[(temp >>> 24) ] & 0xff) ) ^ rcon[i]; rek[keyOffset + 7] = rek[keyOffset + 1] ^ rek[keyOffset + 6]; rek[keyOffset + 8] = rek[keyOffset + 2] ^ rek[keyOffset + 7]; rek[keyOffset + 9] = rek[keyOffset + 3] ^ rek[keyOffset + 8]; if (++i == 8) { return; } rek[keyOffset + 10] = rek[keyOffset + 4] ^ rek[keyOffset + 9]; rek[keyOffset + 11] = rek[keyOffset + 5] ^ rek[keyOffset + 10]; keyOffset += 6; } } rek[keyOffset + 6] = (cipherKey[24] ) << 24 | (cipherKey[25] & 0xff) << 16 | (cipherKey[26] & 0xff) << 8 | (cipherKey[27] & 0xff); rek[keyOffset + 7] = (cipherKey[28] ) << 24 | (cipherKey[29] & 0xff) << 16 | (cipherKey[30] & 0xff) << 8 | (cipherKey[31] & 0xff); if (Nk == 8) { for (;;) { temp = rek[keyOffset + 7]; rek[keyOffset + 8] = rek[keyOffset] ^ ((Se[(temp >>> 16) & 0xff] ) << 24) ^ ((Se[(temp >>> 8) & 0xff] & 0xff) << 16) ^ ((Se[(temp ) & 0xff] & 0xff) << 8) ^ ((Se[(temp >>> 24) ] & 0xff) ) ^ rcon[i]; rek[keyOffset + 9] = rek[keyOffset + 1] ^ rek[keyOffset + 8]; rek[keyOffset + 10] = rek[keyOffset + 2] ^ rek[keyOffset + 9]; rek[keyOffset + 11] = rek[keyOffset + 3] ^ rek[keyOffset + 10]; if (++i == 7) { return; } temp = rek[keyOffset + 11]; rek[keyOffset + 12] = rek[keyOffset + 4] ^ ((Se[(temp >>> 24) ] ) << 24) ^ ((Se[(temp >>> 16) & 0xff] & 0xff) << 16) ^ ((Se[(temp >>> 8) & 0xff] & 0xff) << 8) ^ ((Se[(temp ) & 0xff] & 0xff)); rek[keyOffset + 13] = rek[keyOffset + 5] ^ rek[keyOffset + 12]; rek[keyOffset + 14] = rek[keyOffset + 6] ^ rek[keyOffset + 13]; rek[keyOffset + 15] = rek[keyOffset + 7] ^ rek[keyOffset + 14]; keyOffset += 8; } } } */ /** * Compute the decryption schedule from the encryption schedule . */ private void invertKey() { int d = 0, e = 4 * Nr, w; /* * apply the inverse MixColumn transform to all round keys * but the first and the last: */ rdk[d] = rek[e]; rdk[d + 1] = rek[e + 1]; rdk[d + 2] = rek[e + 2]; rdk[d + 3] = rek[e + 3]; d += 4; e -= 4; for (int r = 1; r < Nr; r++) { w = rek[e]; rdk[d] = Td0[Se[(w >>> 24)] & 0xff] ^ Td1[Se[(w >>> 16) & 0xff] & 0xff] ^ Td2[Se[(w >>> 8) & 0xff] & 0xff] ^ Td3[Se[(w) & 0xff] & 0xff]; w = rek[e + 1]; rdk[d + 1] = Td0[Se[(w >>> 24)] & 0xff] ^ Td1[Se[(w >>> 16) & 0xff] & 0xff] ^ Td2[Se[(w >>> 8) & 0xff] & 0xff] ^ Td3[Se[(w) & 0xff] & 0xff]; w = rek[e + 2]; rdk[d + 2] = Td0[Se[(w >>> 24)] & 0xff] ^ Td1[Se[(w >>> 16) & 0xff] & 0xff] ^ Td2[Se[(w >>> 8) & 0xff] & 0xff] ^ Td3[Se[(w) & 0xff] & 0xff]; w = rek[e + 3]; rdk[d + 3] = Td0[Se[(w >>> 24)] & 0xff] ^ Td1[Se[(w >>> 16) & 0xff] & 0xff] ^ Td2[Se[(w >>> 8) & 0xff] & 0xff] ^ Td3[Se[(w) & 0xff] & 0xff]; d += 4; e -= 4; } rdk[d] = rek[e]; rdk[d + 1] = rek[e + 1]; rdk[d + 2] = rek[e + 2]; rdk[d + 3] = rek[e + 3]; } /** * Setup the AES key schedule for encryption, decryption, or both. * * @param cipherKey the cipher key (128, 192, or 256 bits). * @param keyBits size of the cipher key in bits. * @param direction cipher direction (DIR_ENCRYPT, DIR_DECRYPT, or DIR_BOTH). */ public void makeKey(byte[] cipherKey, int keyBits, int direction) throws RuntimeException { // check key size: if (keyBits != 128 && keyBits != 192 && keyBits != 256) { throw new RuntimeException("Invalid AES key size (" + keyBits + " bits)"); } Nk = keyBits >>> 5; Nr = Nk + 6; Nw = 4 * (Nr + 1); rek = new int[Nw]; rdk = new int[Nw]; if ((direction & DIR_BOTH) != 0) { expandKey(cipherKey); /* for (int r = 0; r <= Nr; r++) { System.out.print("RK" + r + "="); for (int i = 0; i < 4; i++) { int w = rek[4*r + i]; System.out.print(" " + Integer.toHexString(w)); } System.out.println(); } */ if ((direction & DIR_DECRYPT) != 0) { invertKey(); } } } /** * Setup the AES key schedule (any cipher direction). * * @param cipherKey the cipher key (128, 192, or 256 bits). * @param keyBits size of the cipher key in bits. */ public void makeKey(byte[] cipherKey, int keyBits) throws RuntimeException { makeKey(cipherKey, keyBits, DIR_BOTH); } /** * Encrypt exactly one block (BLOCK_SIZE bytes) of plaintext. * * @param pt plaintext block. * @param ct ciphertext block. */ public void encrypt(byte[] pt, byte[] ct) { /* * map byte array block to cipher state * and add initial round key: */ int k = 0, v; int t0 = ((pt[0]) << 24 | (pt[1] & 0xff) << 16 | (pt[2] & 0xff) << 8 | (pt[3] & 0xff)) ^ rek[0]; int t1 = ((pt[4]) << 24 | (pt[5] & 0xff) << 16 | (pt[6] & 0xff) << 8 | (pt[7] & 0xff)) ^ rek[1]; int t2 = ((pt[8]) << 24 | (pt[9] & 0xff) << 16 | (pt[10] & 0xff) << 8 | (pt[11] & 0xff)) ^ rek[2]; int t3 = ((pt[12]) << 24 | (pt[13] & 0xff) << 16 | (pt[14] & 0xff) << 8 | (pt[15] & 0xff)) ^ rek[3]; /* * Nr - 1 full rounds: */ for (int r = 1; r < Nr; r++) { k += 4; int a0 = Te0[(t0 >>> 24)] ^ Te1[(t1 >>> 16) & 0xff] ^ Te2[(t2 >>> 8) & 0xff] ^ Te3[(t3) & 0xff] ^ rek[k]; int a1 = Te0[(t1 >>> 24)] ^ Te1[(t2 >>> 16) & 0xff] ^ Te2[(t3 >>> 8) & 0xff] ^ Te3[(t0) & 0xff] ^ rek[k + 1]; int a2 = Te0[(t2 >>> 24)] ^ Te1[(t3 >>> 16) & 0xff] ^ Te2[(t0 >>> 8) & 0xff] ^ Te3[(t1) & 0xff] ^ rek[k + 2]; int a3 = Te0[(t3 >>> 24)] ^ Te1[(t0 >>> 16) & 0xff] ^ Te2[(t1 >>> 8) & 0xff] ^ Te3[(t2) & 0xff] ^ rek[k + 3]; t0 = a0; t1 = a1; t2 = a2; t3 = a3; } /* * last round lacks MixColumn: */ k += 4; v = rek[k]; ct[0] = (byte) (Se[(t0 >>> 24)] ^ (v >>> 24)); ct[1] = (byte) (Se[(t1 >>> 16) & 0xff] ^ (v >>> 16)); ct[2] = (byte) (Se[(t2 >>> 8) & 0xff] ^ (v >>> 8)); ct[3] = (byte) (Se[(t3) & 0xff] ^ (v)); v = rek[k + 1]; ct[4] = (byte) (Se[(t1 >>> 24)] ^ (v >>> 24)); ct[5] = (byte) (Se[(t2 >>> 16) & 0xff] ^ (v >>> 16)); ct[6] = (byte) (Se[(t3 >>> 8) & 0xff] ^ (v >>> 8)); ct[7] = (byte) (Se[(t0) & 0xff] ^ (v)); v = rek[k + 2]; ct[8] = (byte) (Se[(t2 >>> 24)] ^ (v >>> 24)); ct[9] = (byte) (Se[(t3 >>> 16) & 0xff] ^ (v >>> 16)); ct[10] = (byte) (Se[(t0 >>> 8) & 0xff] ^ (v >>> 8)); ct[11] = (byte) (Se[(t1) & 0xff] ^ (v)); v = rek[k + 3]; ct[12] = (byte) (Se[(t3 >>> 24)] ^ (v >>> 24)); ct[13] = (byte) (Se[(t0 >>> 16) & 0xff] ^ (v >>> 16)); ct[14] = (byte) (Se[(t1 >>> 8) & 0xff] ^ (v >>> 8)); ct[15] = (byte) (Se[(t2) & 0xff] ^ (v)); } /** * Decrypt exactly one block (BLOCK_SIZE bytes) of ciphertext. * * @param ct ciphertext block. * @param pt plaintext block. */ public void decrypt(byte[] ct, byte[] pt) { /* * map byte array block to cipher state * and add initial round key: */ int k = 0, v; int t0 = ((ct[0]) << 24 | (ct[1] & 0xff) << 16 | (ct[2] & 0xff) << 8 | (ct[3] & 0xff)) ^ rdk[0]; int t1 = ((ct[4]) << 24 | (ct[5] & 0xff) << 16 | (ct[6] & 0xff) << 8 | (ct[7] & 0xff)) ^ rdk[1]; int t2 = ((ct[8]) << 24 | (ct[9] & 0xff) << 16 | (ct[10] & 0xff) << 8 | (ct[11] & 0xff)) ^ rdk[2]; int t3 = ((ct[12]) << 24 | (ct[13] & 0xff) << 16 | (ct[14] & 0xff) << 8 | (ct[15] & 0xff)) ^ rdk[3]; /* * Nr - 1 full rounds: */ for (int r = 1; r < Nr; r++) { k += 4; int a0 = Td0[(t0 >>> 24)] ^ Td1[(t3 >>> 16) & 0xff] ^ Td2[(t2 >>> 8) & 0xff] ^ Td3[(t1) & 0xff] ^ rdk[k]; int a1 = Td0[(t1 >>> 24)] ^ Td1[(t0 >>> 16) & 0xff] ^ Td2[(t3 >>> 8) & 0xff] ^ Td3[(t2) & 0xff] ^ rdk[k + 1]; int a2 = Td0[(t2 >>> 24)] ^ Td1[(t1 >>> 16) & 0xff] ^ Td2[(t0 >>> 8) & 0xff] ^ Td3[(t3) & 0xff] ^ rdk[k + 2]; int a3 = Td0[(t3 >>> 24)] ^ Td1[(t2 >>> 16) & 0xff] ^ Td2[(t1 >>> 8) & 0xff] ^ Td3[(t0) & 0xff] ^ rdk[k + 3]; t0 = a0; t1 = a1; t2 = a2; t3 = a3; } /* * last round lacks MixColumn: */ k += 4; v = rdk[k]; pt[0] = (byte) (Sd[(t0 >>> 24)] ^ (v >>> 24)); pt[1] = (byte) (Sd[(t3 >>> 16) & 0xff] ^ (v >>> 16)); pt[2] = (byte) (Sd[(t2 >>> 8) & 0xff] ^ (v >>> 8)); pt[3] = (byte) (Sd[(t1) & 0xff] ^ (v)); v = rdk[k + 1]; pt[4] = (byte) (Sd[(t1 >>> 24)] ^ (v >>> 24)); pt[5] = (byte) (Sd[(t0 >>> 16) & 0xff] ^ (v >>> 16)); pt[6] = (byte) (Sd[(t3 >>> 8) & 0xff] ^ (v >>> 8)); pt[7] = (byte) (Sd[(t2) & 0xff] ^ (v)); v = rdk[k + 2]; pt[8] = (byte) (Sd[(t2 >>> 24)] ^ (v >>> 24)); pt[9] = (byte) (Sd[(t1 >>> 16) & 0xff] ^ (v >>> 16)); pt[10] = (byte) (Sd[(t0 >>> 8) & 0xff] ^ (v >>> 8)); pt[11] = (byte) (Sd[(t3) & 0xff] ^ (v)); v = rdk[k + 3]; pt[12] = (byte) (Sd[(t3 >>> 24)] ^ (v >>> 24)); pt[13] = (byte) (Sd[(t2 >>> 16) & 0xff] ^ (v >>> 16)); pt[14] = (byte) (Sd[(t1 >>> 8) & 0xff] ^ (v >>> 8)); pt[15] = (byte) (Sd[(t0) & 0xff] ^ (v)); } /** * Destroy all sensitive information in this object. */ protected final void finalize() { if (rek != null) { for (int i = 0; i < rek.length; i++) { rek[i] = 0; } rek = null; } if (rdk != null) { for (int i = 0; i < rdk.length; i++) { rdk[i] = 0; } rdk = null; } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/ByteUtils.java ================================================ package com.quincysx.crypto.bip39; /** * @author QuincySx * @date 2018/5/15 上午10:34 */ final class ByteUtils { static int next11Bits(byte[] bytes, int offset) { final int skip = offset / 8; final int lowerBitsToRemove = (3 * 8 - 11) - (offset % 8); return (((int) bytes[skip] & 0xff) << 16 | ((int) bytes[skip + 1] & 0xff) << 8 | (lowerBitsToRemove < 8 ? ((int) bytes[skip + 2] & 0xff) : 0)) >> lowerBitsToRemove & (1 << 11) - 1; } static void writeNext11(byte[] bytes, int value, int offset) { int skip = offset / 8; int bitSkip = offset % 8; {//byte 0 byte firstValue = bytes[skip]; byte toWrite = (byte) (value >> (3 + bitSkip)); bytes[skip] = (byte) (firstValue | toWrite); } {//byte 1 byte valueInByte = bytes[skip + 1]; final int i = 5 - bitSkip; byte toWrite = (byte) (i > 0 ? (value << i) : (value >> -i)); bytes[skip + 1] = (byte) (valueInByte | toWrite); } if (bitSkip >= 6) {//byte 2 byte valueInByte = bytes[skip + 2]; byte toWrite = (byte) (value << 13 - bitSkip); bytes[skip + 2] = (byte) (valueInByte | toWrite); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/CharSequenceComparators.java ================================================ package com.quincysx.crypto.bip39; import java.util.Comparator; /** * @author QuincySx * @date 2018/5/15 上午11:25 */ enum CharSequenceComparators implements Comparator { ALPHABETICAL { @Override public int compare(final CharSequence o1, final CharSequence o2) { final int length1 = o1.length(); final int length2 = o2.length(); final int length = Math.min(length1, length2); for (int i = 0; i < length; i++) { final int compare = Character.compare(o1.charAt(i), o2.charAt(i)); if (compare != 0) return compare; } return Integer.compare(length1, length2); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/CharSequenceSplitter.java ================================================ package com.quincysx.crypto.bip39; import java.util.LinkedList; import java.util.List; /** * @author QuincySx * @date 2018/5/15 上午11:15 */ final class CharSequenceSplitter { private final char separator1; private final char separator2; CharSequenceSplitter(final char separator1, final char separator2) { this.separator1 = separator1; this.separator2 = separator2; } List split(final CharSequence charSequence) { final LinkedList list = new LinkedList<>(); int start = 0; final int length = charSequence.length(); for (int i = 0; i < length; i++) { final char c = charSequence.charAt(i); if (c == separator1 || c == separator2) { list.add(charSequence.subSequence(start, i)); start = i + 1; } } list.add(charSequence.subSequence(start, length)); return list; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/MnemonicGenerator.java ================================================ package com.quincysx.crypto.bip39; import com.quincysx.crypto.utils.SHA256; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * @author QuincySx * @date 2018/5/15 上午10:21 */ public final class MnemonicGenerator { private final WordList wordList; /** * Create a generator using the given word list. * * @param wordList A known ordered list of 2048 words to select from. */ public MnemonicGenerator(final WordList wordList) { this.wordList = wordList; } public List createMnemonic( final CharSequence entropyHex) { final int length = entropyHex.length(); if (length % 2 == 1) throw new RuntimeException("Length of hex chars must be divisible by 2"); final byte[] entropy = new byte[length / 2]; try { for (int i = 0, j = 0; i < length; i += 2, j++) { entropy[j] = (byte) (parseHex(entropyHex.charAt(i)) << 4 | parseHex(entropyHex.charAt(i + 1))); } return createMnemonic(entropy); } finally { Arrays.fill(entropy, (byte) 0); } } public List createMnemonic( final byte[] entropy) { final int[] wordIndexes = wordIndexes(entropy); try { return createMnemonic(wordIndexes); } finally { Arrays.fill(wordIndexes, 0); } } private List createMnemonic( final int[] wordIndexes) { List mnemonicList = new ArrayList<>(); final String space = String.valueOf(wordList.getSpace()); for (int i = 0; i < wordIndexes.length; i++) { mnemonicList.add(wordList.getWord(wordIndexes[i])); } return mnemonicList; } private static int[] wordIndexes(byte[] entropy) { final int ent = entropy.length * 8; entropyLengthPreChecks(ent); final byte[] entropyWithChecksum = Arrays.copyOf(entropy, entropy.length + 1); entropyWithChecksum[entropy.length] = firstByteOfSha256(entropy); //checksum length final int cs = ent / 32; //mnemonic length final int ms = (ent + cs) / 11; //get the indexes into the word list final int[] wordIndexes = new int[ms]; for (int i = 0, wi = 0; wi < ms; i += 11, wi++) { wordIndexes[wi] = ByteUtils.next11Bits(entropyWithChecksum, i); } return wordIndexes; } static byte firstByteOfSha256(final byte[] entropy) { final byte[] hash = SHA256.sha256(entropy); final byte firstByte = hash[0]; Arrays.fill(hash, (byte) 0); return firstByte; } private static void entropyLengthPreChecks(final int ent) { if (ent < 128) throw new RuntimeException("Entropy too low, 128-256 bits allowed"); if (ent > 256) throw new RuntimeException("Entropy too high, 128-256 bits allowed"); if (ent % 32 > 0) throw new RuntimeException("Number of entropy bits must be divisible by 32"); } private static int parseHex(char c) { if (c >= '0' && c <= '9') return c - '0'; if (c >= 'a' && c <= 'f') return (c - 'a') + 10; if (c >= 'A' && c <= 'F') return (c - 'A') + 10; throw new RuntimeException("Invalid hex char '" + c + '\''); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/MnemonicValidator.java ================================================ package com.quincysx.crypto.bip39; import com.quincysx.crypto.bip39.validation.InvalidChecksumException; import com.quincysx.crypto.bip39.validation.InvalidWordCountException; import com.quincysx.crypto.bip39.validation.UnexpectedWhiteSpaceException; import com.quincysx.crypto.bip39.validation.WordNotFoundException; import java.util.Arrays; import java.util.Collection; import java.util.Comparator; /** * @author QuincySx * @date 2018/5/15 上午11:14 */ public final class MnemonicValidator { private final WordAndIndex[] words; private final CharSequenceSplitter charSequenceSplitter; private final NFKDNormalizer normalizer; private MnemonicValidator(final WordList wordList) { normalizer = new WordListMapNormalization(wordList); words = new WordAndIndex[1 << 11]; for (int i = 0; i < 1 << 11; i++) { words[i] = new WordAndIndex(i, wordList.getWord(i)); } charSequenceSplitter = new CharSequenceSplitter(wordList.getSpace(), Normalization.normalizeNFKD(wordList.getSpace())); Arrays.sort(words, wordListSortOrder); } /** * Get a Mnemonic validator for the given word list. * No normalization is currently performed, this is an open issue: https://github.com/NovaCrypto/BIP39/issues/13 * * @param wordList A WordList implementation * @return A validator */ public static MnemonicValidator ofWordList(final WordList wordList) { return new MnemonicValidator(wordList); } /** * Check that the supplied mnemonic fits the BIP0039 spec. * * @param mnemonic The memorable list of words * @throws InvalidChecksumException If the last bytes don't match the expected last bytes * @throws InvalidWordCountException If the number of words is not a multiple of 3, 24 or fewer * @throws WordNotFoundException If a word in the mnemonic is not present in the word list * @throws UnexpectedWhiteSpaceException Occurs if one of the supplied words is empty, e.g. a double space */ public void validate(final CharSequence mnemonic) throws InvalidChecksumException, InvalidWordCountException, WordNotFoundException, UnexpectedWhiteSpaceException { validate(charSequenceSplitter.split(mnemonic)); } /** * Check that the supplied mnemonic fits the BIP0039 spec. *

* The purpose of this method overload is to avoid constructing a mnemonic String if you have gathered a list of * words from the user. * * @param mnemonic The memorable list of words * @throws InvalidChecksumException If the last bytes don't match the expected last bytes * @throws InvalidWordCountException If the number of words is not a multiple of 3, 24 or fewer * @throws WordNotFoundException If a word in the mnemonic is not present in the word list * @throws UnexpectedWhiteSpaceException Occurs if one of the supplied words is empty */ public void validate(final Collection mnemonic) throws InvalidChecksumException, InvalidWordCountException, WordNotFoundException, UnexpectedWhiteSpaceException { final int[] wordIndexes = findWordIndexes(mnemonic); try { validate(wordIndexes); } finally { Arrays.fill(wordIndexes, 0); } } private static void validate(final int[] wordIndexes) throws InvalidWordCountException, InvalidChecksumException { final int ms = wordIndexes.length; final int entPlusCs = ms * 11; final int ent = (entPlusCs * 32) / 33; final int cs = ent / 32; if (entPlusCs != ent + cs) throw new InvalidWordCountException(); // final byte[] entropyWithChecksum = new byte[(entPlusCs + 7) / 8]; // // wordIndexesToEntropyWithCheckSum(wordIndexes, entropyWithChecksum); // Arrays.fill(wordIndexes, 0); // // final byte[] entropy = Arrays.copyOf(entropyWithChecksum, entropyWithChecksum.length - 1); // final byte lastByte = entropyWithChecksum[entropyWithChecksum.length - 1]; // Arrays.fill(entropyWithChecksum, (byte) 0); // final byte sha = MnemonicGenerator.firstByteOfSha256(entropy); // // final byte mask = maskOfFirstNBits(cs); // // if (((sha ^ lastByte) & mask) != 0) // throw new InvalidChecksumException(); } private int[] findWordIndexes(final Collection split) throws UnexpectedWhiteSpaceException, WordNotFoundException { final int ms = split.size(); final int[] result = new int[ms]; int i = 0; for (final CharSequence buffer : split) { if (buffer.length() == 0) { throw new UnexpectedWhiteSpaceException(); } result[i++] = findWordIndex(buffer); } return result; } private int findWordIndex(final CharSequence buffer) throws WordNotFoundException { final WordAndIndex key = new WordAndIndex(-1, buffer); final int index = Arrays.binarySearch(words, key, wordListSortOrder); if (index < 0) { final int insertionPoint = -index - 1; int suggestion = insertionPoint == 0 ? insertionPoint : insertionPoint - 1; if (suggestion + 1 == words.length) suggestion--; throw new WordNotFoundException(buffer, words[suggestion].word, words[suggestion + 1].word); } return words[index].index; } private static void wordIndexesToEntropyWithCheckSum(final int[] wordIndexes, final byte[] entropyWithChecksum) { for (int i = 0, bi = 0; i < wordIndexes.length; i++, bi += 11) { ByteUtils.writeNext11(entropyWithChecksum, wordIndexes[i], bi); } } private static byte maskOfFirstNBits(final int n) { return (byte) ~((1 << (8 - n)) - 1); } private static final Comparator wordListSortOrder = new Comparator() { @Override public int compare(final WordAndIndex o1, final WordAndIndex o2) { return CharSequenceComparators.ALPHABETICAL.compare(o1.normalized, o2.normalized); } }; private class WordAndIndex { final CharSequence word; final String normalized; final int index; WordAndIndex(final int i, final CharSequence word) { this.word = word; normalized = normalizer.normalize(word); index = i; } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/NFKDNormalizer.java ================================================ package com.quincysx.crypto.bip39; /** * @author QuincySx * @date 2018/5/15 上午10:41 */ public interface NFKDNormalizer { String normalize(CharSequence charSequence); } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/Normalization.java ================================================ package com.quincysx.crypto.bip39; import java.text.Normalizer; /** * @author QuincySx * @date 2018/5/15 上午10:40 */ final class Normalization { static String normalizeNFKD(final String string) { return Normalizer.normalize(string, Normalizer.Form.NFKD); } static char normalizeNFKD(final char c) { return normalizeNFKD("" + c).charAt(0); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/PBKDF2WithHmacSHA512.java ================================================ package com.quincysx.crypto.bip39; /** * @author QuincySx * @date 2018/5/15 上午10:18 */ public interface PBKDF2WithHmacSHA512 { byte[] hash(final char[] chars, final byte[] salt); } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/RandomSeed.java ================================================ package com.quincysx.crypto.bip39; import java.security.SecureRandom; import java.util.Random; /** * @author QuincySx * @date 2018/3/13 上午11:06 */ public class RandomSeed { public static byte[] random(WordCount words) { return random(words, new SecureRandom()); } public static byte[] random(WordCount words, Random random) { byte[] randomSeed = new byte[words.byteLength()]; random.nextBytes(randomSeed); return randomSeed; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/SeedCalculator.java ================================================ package com.quincysx.crypto.bip39; import android.util.Log; import com.quincysx.crypto.utils.HexUtils; import java.io.UnsupportedEncodingException; import java.util.Arrays; import java.util.List; import static com.quincysx.crypto.bip39.Normalization.normalizeNFKD; /** * @author QuincySx * @date 2018/5/15 上午10:38 */ public final class SeedCalculator { private final byte[] fixedSalt = getUtf8Bytes("mnemonic"); private final PBKDF2WithHmacSHA512 hashAlgorithm; public SeedCalculator(final PBKDF2WithHmacSHA512 hashAlgorithm) { this.hashAlgorithm = hashAlgorithm; } /** * Creates a seed calculator using {@link SpongyCastlePBKDF2WithHmacSHA512} which is the most compatible. * Use {@link SeedCalculator#SeedCalculator(PBKDF2WithHmacSHA512)} to supply another. */ public SeedCalculator() { this(SpongyCastlePBKDF2WithHmacSHA512.INSTANCE); } public byte[] calculateSeed(final List mnemonicList, final String passphrase) { if (mnemonicList == null || mnemonicList.size() < 3) { throw new RuntimeException("The dictionary cannot be empty and the number of words must not be less than 3"); } StringBuilder stringBuilder = new StringBuilder(); for (String str : mnemonicList) { stringBuilder.append(str).append(" "); } String mnemonic = stringBuilder.substring(0, stringBuilder.length() - 1).toString(); return calculateSeed(mnemonic, passphrase); } /** * Calculate the seed given a mnemonic and corresponding passphrase. * The phrase is not checked for validity here, for that use a {@link MnemonicValidator}. *

* Due to normalization, these need to be {@link String}, and not {@link CharSequence}, this is an open issue: * https://github.com/NovaCrypto/BIP39/issues/7 *

* If you have a list of words selected from a word list, you can use {@link #withWordsFromWordList} then * {@link SeedCalculatorByWordListLookUp#calculateSeed} * * @param mnemonic The memorable list of words * @param passphrase An optional passphrase, use "" if not required * @return a seed for HD wallet generation */ public byte[] calculateSeed(final String mnemonic, final String passphrase) { final char[] chars = normalizeNFKD(mnemonic).toCharArray(); try { return calculateSeed(chars, passphrase); } finally { Arrays.fill(chars, '\0'); } } byte[] calculateSeed(final char[] mnemonicChars, final String passphrase) { final String normalizedPassphrase = normalizeNFKD(passphrase); final byte[] salt2 = getUtf8Bytes(normalizedPassphrase); final byte[] salt = combine(fixedSalt, salt2); clear(salt2); final byte[] encoded = hash(mnemonicChars, salt); clear(salt); return encoded; } public SeedCalculatorByWordListLookUp withWordsFromWordList(final WordList wordList) { return new SeedCalculatorByWordListLookUp(this, wordList); } private static byte[] combine(final byte[] array1, final byte[] array2) { final byte[] bytes = new byte[array1.length + array2.length]; System.arraycopy(array1, 0, bytes, 0, array1.length); System.arraycopy(array2, 0, bytes, array1.length, bytes.length - array1.length); return bytes; } private static void clear(final byte[] salt) { Arrays.fill(salt, (byte) 0); } private byte[] hash(final char[] chars, final byte[] salt) { return hashAlgorithm.hash(chars, salt); } private static byte[] getUtf8Bytes(final String string) { try { return string.getBytes("UTF-8"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } return null; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/SeedCalculatorByWordListLookUp.java ================================================ package com.quincysx.crypto.bip39; import java.util.Arrays; import java.util.Collection; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Map; /** * @author QuincySx * @date 2018/5/15 上午10:39 */ public final class SeedCalculatorByWordListLookUp { private final SeedCalculator seedCalculator; private final Map map = new HashMap<>(); private final NFKDNormalizer normalizer; SeedCalculatorByWordListLookUp(final SeedCalculator seedCalculator, final WordList wordList) { this.seedCalculator = seedCalculator; normalizer = new WordListMapNormalization(wordList); for (int i = 0; i < 1 << 11; i++) { final String word = normalizer.normalize(wordList.getWord(i)); map.put(word, word.toCharArray()); } } /** * Calculate the seed given a mnemonic and corresponding passphrase. * The phrase is not checked for validity here, for that use a {@link MnemonicValidator}. *

* The purpose of this method is to avoid constructing a mnemonic String if you have gathered a list of * words from the user and also to avoid having to normalize it, all words in the {@link WordList} are normalized * instead. *

* Due to normalization, the passphrase still needs to be {@link String}, and not {@link CharSequence}, this is an * open issue: https://github.com/NovaCrypto/BIP39/issues/7 * * @param mnemonic The memorable list of words, ideally selected from the word list that was supplied while creating this object. * @param passphrase An optional passphrase, use "" if not required * @return a seed for HD wallet generation */ public byte[] calculateSeed(final Collection mnemonic, final String passphrase) { final int words = mnemonic.size(); final char[][] chars = new char[words][]; final List toClear = new LinkedList<>(); int count = 0; int wordIndex = 0; for (final CharSequence word : mnemonic) { char[] wordChars = map.get(normalizer.normalize(word)); if (wordChars == null) { wordChars = normalizer.normalize(word).toCharArray(); toClear.add(wordChars); } chars[wordIndex++] = wordChars; count += wordChars.length; } count += words - 1; final char[] mnemonicChars = new char[count]; try { int index = 0; for (int i = 0; i < chars.length; i++) { System.arraycopy(chars[i], 0, mnemonicChars, index, chars[i].length); index += chars[i].length; if (i < chars.length - 1) { mnemonicChars[index++] = ' '; } } return seedCalculator.calculateSeed(mnemonicChars, passphrase); } finally { Arrays.fill(mnemonicChars, '\0'); Arrays.fill(chars, null); for (final char[] charsToClear : toClear) Arrays.fill(charsToClear, '\0'); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/SpongyCastlePBKDF2WithHmacSHA512.java ================================================ package com.quincysx.crypto.bip39; import org.spongycastle.crypto.PBEParametersGenerator; import org.spongycastle.crypto.digests.SHA512Digest; import org.spongycastle.crypto.generators.PKCS5S2ParametersGenerator; import org.spongycastle.crypto.params.KeyParameter; /** * @author QuincySx * @date 2018/5/15 上午10:20 */ public enum SpongyCastlePBKDF2WithHmacSHA512 implements PBKDF2WithHmacSHA512 { INSTANCE; @Override public byte[] hash(char[] chars, byte[] salt) { PKCS5S2ParametersGenerator generator = new PKCS5S2ParametersGenerator(new SHA512Digest()); generator.init(PBEParametersGenerator.PKCS5PasswordToUTF8Bytes(chars), salt, 2048); KeyParameter key = (KeyParameter) generator.generateDerivedMacParameters(512); return key.getKey(); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/WordCount.java ================================================ package com.quincysx.crypto.bip39; /** * @author QuincySx * @date 2018/3/2 下午4:27 * 词语个数的枚举 */ public enum WordCount { /** * 3个助记词 */ // THREE(27), /** * 6个助记词 */ // SIX(54), /** * 9个助记词 */ // NINE(72), /** * 12个助记词 */ TWELVE(128), /** * 15个助记词 */ FIFTEEN(160), /** * 18个助记词 */ EIGHTEEN(192), /** * 21个助记词 */ TWENTY_ONE(224), /** * 24个助记词 */ TWENTY_FOUR(256); private final int bitLength; WordCount(int bitLength) { this.bitLength = bitLength; } public int bitLength() { return bitLength; } public int byteLength() { return bitLength / 8; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/WordList.java ================================================ /* * BIP39 library, a Java implementation of BIP39 * Copyright (C) 2017 Alan Evans, NovaCrypto * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Original source: https://github.com/NovaCrypto/BIP39 * You can contact the authors via github issues. */ package com.quincysx.crypto.bip39; public interface WordList { /** * Get a word in the word list. * * @param index Index of word in the word list [0..2047] inclusive. * @return the word from the list. */ String getWord(final int index); int getIndex(final String word); /** * Get the space character for this language. * * @return a whitespace character. */ char getSpace(); } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/WordListMapNormalization.java ================================================ package com.quincysx.crypto.bip39; import java.text.Normalizer; import java.util.HashMap; import java.util.Map; /** * @author QuincySx * @date 2018/5/15 上午10:41 */ public class WordListMapNormalization implements NFKDNormalizer { private final Map normalizedMap = new HashMap<>(); WordListMapNormalization(final WordList wordList) { for (int i = 0; i < 1 << 11; i++) { final String word = wordList.getWord(i); final String normalized = Normalizer.normalize(word, Normalizer.Form.NFKD); normalizedMap.put(word, normalized); normalizedMap.put(normalized, normalized); normalizedMap.put(Normalizer.normalize(word, Normalizer.Form.NFC), normalized); } } @Override public String normalize(final CharSequence charSequence) { final String normalized = normalizedMap.get(charSequence); if (normalized != null) return normalized; return Normalizer.normalize(charSequence, Normalizer.Form.NFKD); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/exception/MnemonicException.java ================================================ /* * * * Copyright 2014 http://Bither.net * * * * Licensed under the Apache License, Version 2.0 (the "License"); * * you may not use this file except in compliance with the License. * * You may obtain a copy of the License at * * * * http://www.apache.org/licenses/LICENSE-2.0 * * * * Unless required by applicable law or agreed to in writing, software * * distributed under the License is distributed on an "AS IS" BASIS, * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * * See the License for the specific language governing permissions and * * limitations under the License. * */ package com.quincysx.crypto.bip39.exception; /** * Exceptions thrown by the MnemonicCode module. */ @SuppressWarnings("serial") public class MnemonicException extends Exception { public MnemonicException() { super(); } public MnemonicException(String msg) { super(msg); } /** * Thrown when an argument to MnemonicCode is the wrong length. */ public static class MnemonicLengthException extends MnemonicException { public MnemonicLengthException(String msg) { super(msg); } } /** * Thrown when a list of MnemonicCode words fails the checksum check. */ public static class MnemonicChecksumException extends MnemonicException { public MnemonicChecksumException() { super(); } } /** * Thrown when a word is encountered which is not in the MnemonicCode's word list. */ public static class MnemonicWordException extends MnemonicException { /** * Contains the word that was not found in the word list. */ public final String badWord; public MnemonicWordException(String badWord) { super(); this.badWord = badWord; } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/validation/InvalidChecksumException.java ================================================ package com.quincysx.crypto.bip39.validation; /** * @author QuincySx * @date 2018/5/15 上午11:19 */ public class InvalidChecksumException extends Exception { public InvalidChecksumException() { super("Invalid checksum"); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/validation/InvalidWordCountException.java ================================================ package com.quincysx.crypto.bip39.validation; /** * @author QuincySx * @date 2018/5/15 上午11:20 */ public class InvalidWordCountException extends Exception { public InvalidWordCountException() { super("Not a correct number of words"); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/validation/UnexpectedWhiteSpaceException.java ================================================ package com.quincysx.crypto.bip39.validation; /** * @author QuincySx * @date 2018/5/15 上午11:20 */ public class UnexpectedWhiteSpaceException extends Exception { public UnexpectedWhiteSpaceException() { super("Unexpected whitespace"); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/validation/WordNotFoundException.java ================================================ package com.quincysx.crypto.bip39.validation; /** * @author QuincySx * @date 2018/5/15 上午11:20 */ public class WordNotFoundException extends Exception { private final CharSequence word; private final CharSequence suggestion1; private final CharSequence suggestion2; public WordNotFoundException( final CharSequence word, final CharSequence suggestion1, final CharSequence suggestion2) { super(String.format( "Word not found in word list \"%s\", suggestions \"%s\", \"%s\"", word, suggestion1, suggestion2)); this.word = word; this.suggestion1 = suggestion1; this.suggestion2 = suggestion2; } public CharSequence getWord() { return word; } public CharSequence getSuggestion1() { return suggestion1; } public CharSequence getSuggestion2() { return suggestion2; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/wordlists/English.java ================================================ /* * BIP39 library, a Java implementation of BIP39 * Copyright (C) 2017 Alan Evans, NovaCrypto * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Original source: https://github.com/NovaCrypto/BIP39 * You can contact the authors via github issues. */ package com.quincysx.crypto.bip39.wordlists; import com.quincysx.crypto.bip39.WordList; /** * Source: https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt */ public enum English implements WordList { INSTANCE; @Override public String getWord(final int index) { return words[index]; } @Override public int getIndex(final String word) { int size = words.length; if (word == null) { for (int i = 0; i < size; i++) if (words[i] == null) return i; } else { for (int i = 0; i < size; i++) if (word.equals(words[i])) return i; } return -1; } @Override public char getSpace() { return ' '; } private final static String[] words = new String[]{ "abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract", "absurd", "abuse", "access", "accident", "account", "accuse", "achieve", "acid", "acoustic", "acquire", "across", "act", "action", "actor", "actress", "actual", "adapt", "add", "addict", "address", "adjust", "admit", "adult", "advance", "advice", "aerobic", "affair", "afford", "afraid", "again", "age", "agent", "agree", "ahead", "aim", "air", "airport", "aisle", "alarm", "album", "alcohol", "alert", "alien", "all", "alley", "allow", "almost", "alone", "alpha", "already", "also", "alter", "always", "amateur", "amazing", "among", "amount", "amused", "analyst", "anchor", "ancient", "anger", "angle", "angry", "animal", "ankle", "announce", "annual", "another", "answer", "antenna", "antique", "anxiety", "any", "apart", "apology", "appear", "apple", "approve", "april", "arch", "arctic", "area", "arena", "argue", "arm", "armed", "armor", "army", "around", "arrange", "arrest", "arrive", "arrow", "art", "artefact", "artist", "artwork", "ask", "aspect", "assault", "asset", "assist", "assume", "asthma", "athlete", "atom", "attack", "attend", "attitude", "attract", "auction", "audit", "august", "aunt", "author", "auto", "autumn", "average", "avocado", "avoid", "awake", "aware", "away", "awesome", "awful", "awkward", "axis", "baby", "bachelor", "bacon", "badge", "bag", "balance", "balcony", "ball", "bamboo", "banana", "banner", "bar", "barely", "bargain", "barrel", "base", "basic", "basket", "battle", "beach", "bean", "beauty", "because", "become", "beef", "before", "begin", "behave", "behind", "believe", "below", "belt", "bench", "benefit", "best", "betray", "better", "between", "beyond", "bicycle", "bid", "bike", "bind", "biology", "bird", "birth", "bitter", "black", "blade", "blame", "blanket", "blast", "bleak", "bless", "blind", "blood", "blossom", "blouse", "blue", "blur", "blush", "board", "boat", "body", "boil", "bomb", "bone", "bonus", "book", "boost", "border", "boring", "borrow", "boss", "bottom", "bounce", "box", "boy", "bracket", "brain", "brand", "brass", "brave", "bread", "breeze", "brick", "bridge", "brief", "bright", "bring", "brisk", "broccoli", "broken", "bronze", "broom", "brother", "brown", "brush", "bubble", "buddy", "budget", "buffalo", "build", "bulb", "bulk", "bullet", "bundle", "bunker", "burden", "burger", "burst", "bus", "business", "busy", "butter", "buyer", "buzz", "cabbage", "cabin", "cable", "cactus", "cage", "cake", "call", "calm", "camera", "camp", "can", "canal", "cancel", "candy", "cannon", "canoe", "canvas", "canyon", "capable", "capital", "captain", "car", "carbon", "card", "cargo", "carpet", "carry", "cart", "case", "cash", "casino", "castle", "casual", "cat", "catalog", "catch", "category", "cattle", "caught", "cause", "caution", "cave", "ceiling", "celery", "cement", "census", "century", "cereal", "certain", "chair", "chalk", "champion", "change", "chaos", "chapter", "charge", "chase", "chat", "cheap", "check", "cheese", "chef", "cherry", "chest", "chicken", "chief", "child", "chimney", "choice", "choose", "chronic", "chuckle", "chunk", "churn", "cigar", "cinnamon", "circle", "citizen", "city", "civil", "claim", "clap", "clarify", "claw", "clay", "clean", "clerk", "clever", "click", "client", "cliff", "climb", "clinic", "clip", "clock", "clog", "close", "cloth", "cloud", "clown", "club", "clump", "cluster", "clutch", "coach", "coast", "coconut", "code", "coffee", "coil", "coin", "collect", "color", "column", "combine", "come", "comfort", "comic", "common", "company", "concert", "conduct", "confirm", "congress", "connect", "consider", "control", "convince", "cook", "cool", "copper", "copy", "coral", "core", "corn", "correct", "cost", "cotton", "couch", "country", "couple", "course", "cousin", "cover", "coyote", "crack", "cradle", "craft", "cram", "crane", "crash", "crater", "crawl", "crazy", "cream", "credit", "creek", "crew", "cricket", "crime", "crisp", "critic", "crop", "cross", "crouch", "crowd", "crucial", "cruel", "cruise", "crumble", "crunch", "crush", "cry", "crystal", "cube", "culture", "cup", "cupboard", "curious", "current", "curtain", "curve", "cushion", "custom", "cute", "cycle", "dad", "damage", "damp", "dance", "danger", "daring", "dash", "daughter", "dawn", "day", "deal", "debate", "debris", "decade", "december", "decide", "decline", "decorate", "decrease", "deer", "defense", "define", "defy", "degree", "delay", "deliver", "demand", "demise", "denial", "dentist", "deny", "depart", "depend", "deposit", "depth", "deputy", "derive", "describe", "desert", "design", "desk", "despair", "destroy", "detail", "detect", "develop", "device", "devote", "diagram", "dial", "diamond", "diary", "dice", "diesel", "diet", "differ", "digital", "dignity", "dilemma", "dinner", "dinosaur", "direct", "dirt", "disagree", "discover", "disease", "dish", "dismiss", "disorder", "display", "distance", "divert", "divide", "divorce", "dizzy", "doctor", "document", "dog", "doll", "dolphin", "domain", "donate", "donkey", "donor", "door", "dose", "double", "dove", "draft", "dragon", "drama", "drastic", "draw", "dream", "dress", "drift", "drill", "drink", "drip", "drive", "drop", "drum", "dry", "duck", "dumb", "dune", "during", "dust", "dutch", "duty", "dwarf", "dynamic", "eager", "eagle", "early", "earn", "earth", "easily", "east", "easy", "echo", "ecology", "economy", "edge", "edit", "educate", "effort", "egg", "eight", "either", "elbow", "elder", "electric", "elegant", "element", "elephant", "elevator", "elite", "else", "embark", "embody", "embrace", "emerge", "emotion", "employ", "empower", "empty", "enable", "enact", "end", "endless", "endorse", "enemy", "energy", "enforce", "engage", "engine", "enhance", "enjoy", "enlist", "enough", "enrich", "enroll", "ensure", "enter", "entire", "entry", "envelope", "episode", "equal", "equip", "era", "erase", "erode", "erosion", "error", "erupt", "escape", "essay", "essence", "estate", "eternal", "ethics", "evidence", "evil", "evoke", "evolve", "exact", "example", "excess", "exchange", "excite", "exclude", "excuse", "execute", "exercise", "exhaust", "exhibit", "exile", "exist", "exit", "exotic", "expand", "expect", "expire", "explain", "expose", "express", "extend", "extra", "eye", "eyebrow", "fabric", "face", "faculty", "fade", "faint", "faith", "fall", "false", "fame", "family", "famous", "fan", "fancy", "fantasy", "farm", "fashion", "fat", "fatal", "father", "fatigue", "fault", "favorite", "feature", "february", "federal", "fee", "feed", "feel", "female", "fence", "festival", "fetch", "fever", "few", "fiber", "fiction", "field", "figure", "file", "film", "filter", "final", "find", "fine", "finger", "finish", "fire", "firm", "first", "fiscal", "fish", "fit", "fitness", "fix", "flag", "flame", "flash", "flat", "flavor", "flee", "flight", "flip", "float", "flock", "floor", "flower", "fluid", "flush", "fly", "foam", "focus", "fog", "foil", "fold", "follow", "food", "foot", "force", "forest", "forget", "fork", "fortune", "forum", "forward", "fossil", "foster", "found", "fox", "fragile", "frame", "frequent", "fresh", "friend", "fringe", "frog", "front", "frost", "frown", "frozen", "fruit", "fuel", "fun", "funny", "furnace", "fury", "future", "gadget", "gain", "galaxy", "gallery", "game", "gap", "garage", "garbage", "garden", "garlic", "garment", "gas", "gasp", "gate", "gather", "gauge", "gaze", "general", "genius", "genre", "gentle", "genuine", "gesture", "ghost", "giant", "gift", "giggle", "ginger", "giraffe", "girl", "give", "glad", "glance", "glare", "glass", "glide", "glimpse", "globe", "gloom", "glory", "glove", "glow", "glue", "goat", "goddess", "gold", "good", "goose", "gorilla", "gospel", "gossip", "govern", "gown", "grab", "grace", "grain", "grant", "grape", "grass", "gravity", "great", "green", "grid", "grief", "grit", "grocery", "group", "grow", "grunt", "guard", "guess", "guide", "guilt", "guitar", "gun", "gym", "habit", "hair", "half", "hammer", "hamster", "hand", "happy", "harbor", "hard", "harsh", "harvest", "hat", "have", "hawk", "hazard", "head", "health", "heart", "heavy", "hedgehog", "height", "hello", "helmet", "help", "hen", "hero", "hidden", "high", "hill", "hint", "hip", "hire", "history", "hobby", "hockey", "hold", "hole", "holiday", "hollow", "home", "honey", "hood", "hope", "horn", "horror", "horse", "hospital", "host", "hotel", "hour", "hover", "hub", "huge", "human", "humble", "humor", "hundred", "hungry", "hunt", "hurdle", "hurry", "hurt", "husband", "hybrid", "ice", "icon", "idea", "identify", "idle", "ignore", "ill", "illegal", "illness", "image", "imitate", "immense", "immune", "impact", "impose", "improve", "impulse", "inch", "include", "income", "increase", "index", "indicate", "indoor", "industry", "infant", "inflict", "inform", "inhale", "inherit", "initial", "inject", "injury", "inmate", "inner", "innocent", "input", "inquiry", "insane", "insect", "inside", "inspire", "install", "intact", "interest", "into", "invest", "invite", "involve", "iron", "island", "isolate", "issue", "item", "ivory", "jacket", "jaguar", "jar", "jazz", "jealous", "jeans", "jelly", "jewel", "job", "join", "joke", "journey", "joy", "judge", "juice", "jump", "jungle", "junior", "junk", "just", "kangaroo", "keen", "keep", "ketchup", "key", "kick", "kid", "kidney", "kind", "kingdom", "kiss", "kit", "kitchen", "kite", "kitten", "kiwi", "knee", "knife", "knock", "know", "lab", "label", "labor", "ladder", "lady", "lake", "lamp", "language", "laptop", "large", "later", "latin", "laugh", "laundry", "lava", "law", "lawn", "lawsuit", "layer", "lazy", "leader", "leaf", "learn", "leave", "lecture", "left", "leg", "legal", "legend", "leisure", "lemon", "lend", "length", "lens", "leopard", "lesson", "letter", "level", "liar", "liberty", "library", "license", "life", "lift", "light", "like", "limb", "limit", "link", "lion", "liquid", "list", "little", "live", "lizard", "load", "loan", "lobster", "local", "lock", "logic", "lonely", "long", "loop", "lottery", "loud", "lounge", "love", "loyal", "lucky", "luggage", "lumber", "lunar", "lunch", "luxury", "lyrics", "machine", "mad", "magic", "magnet", "maid", "mail", "main", "major", "make", "mammal", "man", "manage", "mandate", "mango", "mansion", "manual", "maple", "marble", "march", "margin", "marine", "market", "marriage", "mask", "mass", "master", "match", "material", "math", "matrix", "matter", "maximum", "maze", "meadow", "mean", "measure", "meat", "mechanic", "medal", "media", "melody", "melt", "member", "memory", "mention", "menu", "mercy", "merge", "merit", "merry", "mesh", "message", "metal", "method", "middle", "midnight", "milk", "million", "mimic", "mind", "minimum", "minor", "minute", "miracle", "mirror", "misery", "miss", "mistake", "mix", "mixed", "mixture", "mobile", "model", "modify", "mom", "moment", "monitor", "monkey", "monster", "month", "moon", "moral", "more", "morning", "mosquito", "mother", "motion", "motor", "mountain", "mouse", "move", "movie", "much", "muffin", "mule", "multiply", "muscle", "museum", "mushroom", "music", "must", "mutual", "myself", "mystery", "myth", "naive", "name", "napkin", "narrow", "nasty", "nation", "nature", "near", "neck", "need", "negative", "neglect", "neither", "nephew", "nerve", "nest", "net", "network", "neutral", "never", "news", "next", "nice", "night", "noble", "noise", "nominee", "noodle", "normal", "north", "nose", "notable", "note", "nothing", "notice", "novel", "now", "nuclear", "number", "nurse", "nut", "oak", "obey", "object", "oblige", "obscure", "observe", "obtain", "obvious", "occur", "ocean", "october", "odor", "off", "offer", "office", "often", "oil", "okay", "old", "olive", "olympic", "omit", "once", "one", "onion", "online", "only", "open", "opera", "opinion", "oppose", "option", "orange", "orbit", "orchard", "order", "ordinary", "organ", "orient", "original", "orphan", "ostrich", "other", "outdoor", "outer", "output", "outside", "oval", "oven", "over", "own", "owner", "oxygen", "oyster", "ozone", "pact", "paddle", "page", "pair", "palace", "palm", "panda", "panel", "panic", "panther", "paper", "parade", "parent", "park", "parrot", "party", "pass", "patch", "path", "patient", "patrol", "pattern", "pause", "pave", "payment", "peace", "peanut", "pear", "peasant", "pelican", "pen", "penalty", "pencil", "people", "pepper", "perfect", "permit", "person", "pet", "phone", "photo", "phrase", "physical", "piano", "picnic", "picture", "piece", "pig", "pigeon", "pill", "pilot", "pink", "pioneer", "pipe", "pistol", "pitch", "pizza", "place", "planet", "plastic", "plate", "play", "please", "pledge", "pluck", "plug", "plunge", "poem", "poet", "point", "polar", "pole", "police", "pond", "pony", "pool", "popular", "portion", "position", "possible", "post", "potato", "pottery", "poverty", "powder", "power", "practice", "praise", "predict", "prefer", "prepare", "present", "pretty", "prevent", "price", "pride", "primary", "print", "priority", "prison", "private", "prize", "problem", "process", "produce", "profit", "program", "project", "promote", "proof", "property", "prosper", "protect", "proud", "provide", "public", "pudding", "pull", "pulp", "pulse", "pumpkin", "punch", "pupil", "puppy", "purchase", "purity", "purpose", "purse", "push", "put", "puzzle", "pyramid", "quality", "quantum", "quarter", "question", "quick", "quit", "quiz", "quote", "rabbit", "raccoon", "race", "rack", "radar", "radio", "rail", "rain", "raise", "rally", "ramp", "ranch", "random", "range", "rapid", "rare", "rate", "rather", "raven", "raw", "razor", "ready", "real", "reason", "rebel", "rebuild", "recall", "receive", "recipe", "record", "recycle", "reduce", "reflect", "reform", "refuse", "region", "regret", "regular", "reject", "relax", "release", "relief", "rely", "remain", "remember", "remind", "remove", "render", "renew", "rent", "reopen", "repair", "repeat", "replace", "report", "require", "rescue", "resemble", "resist", "resource", "response", "result", "retire", "retreat", "return", "reunion", "reveal", "review", "reward", "rhythm", "rib", "ribbon", "rice", "rich", "ride", "ridge", "rifle", "right", "rigid", "ring", "riot", "ripple", "risk", "ritual", "rival", "river", "road", "roast", "robot", "robust", "rocket", "romance", "roof", "rookie", "room", "rose", "rotate", "rough", "round", "route", "royal", "rubber", "rude", "rug", "rule", "run", "runway", "rural", "sad", "saddle", "sadness", "safe", "sail", "salad", "salmon", "salon", "salt", "salute", "same", "sample", "sand", "satisfy", "satoshi", "sauce", "sausage", "save", "say", "scale", "scan", "scare", "scatter", "scene", "scheme", "school", "science", "scissors", "scorpion", "scout", "scrap", "screen", "script", "scrub", "sea", "search", "season", "seat", "second", "secret", "section", "security", "seed", "seek", "segment", "select", "sell", "seminar", "senior", "sense", "sentence", "series", "service", "session", "settle", "setup", "seven", "shadow", "shaft", "shallow", "share", "shed", "shell", "sheriff", "shield", "shift", "shine", "ship", "shiver", "shock", "shoe", "shoot", "shop", "short", "shoulder", "shove", "shrimp", "shrug", "shuffle", "shy", "sibling", "sick", "side", "siege", "sight", "sign", "silent", "silk", "silly", "silver", "similar", "simple", "since", "sing", "siren", "sister", "situate", "six", "size", "skate", "sketch", "ski", "skill", "skin", "skirt", "skull", "slab", "slam", "sleep", "slender", "slice", "slide", "slight", "slim", "slogan", "slot", "slow", "slush", "small", "smart", "smile", "smoke", "smooth", "snack", "snake", "snap", "sniff", "snow", "soap", "soccer", "social", "sock", "soda", "soft", "solar", "soldier", "solid", "solution", "solve", "someone", "song", "soon", "sorry", "sort", "soul", "sound", "soup", "source", "south", "space", "spare", "spatial", "spawn", "speak", "special", "speed", "spell", "spend", "sphere", "spice", "spider", "spike", "spin", "spirit", "split", "spoil", "sponsor", "spoon", "sport", "spot", "spray", "spread", "spring", "spy", "square", "squeeze", "squirrel", "stable", "stadium", "staff", "stage", "stairs", "stamp", "stand", "start", "state", "stay", "steak", "steel", "stem", "step", "stereo", "stick", "still", "sting", "stock", "stomach", "stone", "stool", "story", "stove", "strategy", "street", "strike", "strong", "struggle", "student", "stuff", "stumble", "style", "subject", "submit", "subway", "success", "such", "sudden", "suffer", "sugar", "suggest", "suit", "summer", "sun", "sunny", "sunset", "super", "supply", "supreme", "sure", "surface", "surge", "surprise", "surround", "survey", "suspect", "sustain", "swallow", "swamp", "swap", "swarm", "swear", "sweet", "swift", "swim", "swing", "switch", "sword", "symbol", "symptom", "syrup", "system", "table", "tackle", "tag", "tail", "talent", "talk", "tank", "tape", "target", "task", "taste", "tattoo", "taxi", "teach", "team", "tell", "ten", "tenant", "tennis", "tent", "term", "test", "text", "thank", "that", "theme", "then", "theory", "there", "they", "thing", "this", "thought", "three", "thrive", "throw", "thumb", "thunder", "ticket", "tide", "tiger", "tilt", "timber", "time", "tiny", "tip", "tired", "tissue", "title", "toast", "tobacco", "today", "toddler", "toe", "together", "toilet", "token", "tomato", "tomorrow", "tone", "tongue", "tonight", "tool", "tooth", "top", "topic", "topple", "torch", "tornado", "tortoise", "toss", "total", "tourist", "toward", "tower", "town", "toy", "track", "trade", "traffic", "tragic", "train", "transfer", "trap", "trash", "travel", "tray", "treat", "tree", "trend", "trial", "tribe", "trick", "trigger", "trim", "trip", "trophy", "trouble", "truck", "true", "truly", "trumpet", "trust", "truth", "try", "tube", "tuition", "tumble", "tuna", "tunnel", "turkey", "turn", "turtle", "twelve", "twenty", "twice", "twin", "twist", "two", "type", "typical", "ugly", "umbrella", "unable", "unaware", "uncle", "uncover", "under", "undo", "unfair", "unfold", "unhappy", "uniform", "unique", "unit", "universe", "unknown", "unlock", "until", "unusual", "unveil", "update", "upgrade", "uphold", "upon", "upper", "upset", "urban", "urge", "usage", "use", "used", "useful", "useless", "usual", "utility", "vacant", "vacuum", "vague", "valid", "valley", "valve", "van", "vanish", "vapor", "various", "vast", "vault", "vehicle", "velvet", "vendor", "venture", "venue", "verb", "verify", "version", "very", "vessel", "veteran", "viable", "vibrant", "vicious", "victory", "video", "view", "village", "vintage", "violin", "virtual", "virus", "visa", "visit", "visual", "vital", "vivid", "vocal", "voice", "void", "volcano", "volume", "vote", "voyage", "wage", "wagon", "wait", "walk", "wall", "walnut", "want", "warfare", "warm", "warrior", "wash", "wasp", "waste", "water", "wave", "way", "wealth", "weapon", "wear", "weasel", "weather", "web", "wedding", "weekend", "weird", "welcome", "west", "wet", "whale", "what", "wheat", "wheel", "when", "where", "whip", "whisper", "wide", "width", "wife", "wild", "will", "win", "window", "wine", "wing", "wink", "winner", "winter", "wire", "wisdom", "wise", "wish", "witness", "wolf", "woman", "wonder", "wood", "wool", "word", "work", "world", "worry", "worth", "wrap", "wreck", "wrestle", "wrist", "write", "wrong", "yard", "year", "yellow", "you", "young", "youth", "zebra", "zero", "zone", "zoo" }; } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/wordlists/French.java ================================================ /* * BIP39 library, a Java implementation of BIP39 * Copyright (C) 2017 Alan Evans, NovaCrypto * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Original source: https://github.com/NovaCrypto/BIP39 * You can contact the authors via github issues. */ package com.quincysx.crypto.bip39.wordlists; import com.quincysx.crypto.bip39.WordList; /** * Source: https://github.com/bitcoin/bips/blob/master/bip-0039/french.txt */ public enum French implements WordList { INSTANCE; @Override public String getWord(final int index) { return words[index]; } @Override public int getIndex(final String word) { int size = words.length; if (word == null) { for (int i = 0; i < size; i++) if (words[i] == null) return i; } else { for (int i = 0; i < size; i++) if (word.equals(words[i])) return i; } return -1; } @Override public char getSpace() { return ' '; } private final static String[] words = new String[]{ "abaisser", "abandon", "abdiquer", "abeille", "abolir", "aborder", "aboutir", "aboyer", "abrasif", "abreuver", "abriter", "abroger", "abrupt", "absence", "absolu", "absurde", "abusif", "abyssal", "académie", "acajou", "acarien", "accabler", "accepter", "acclamer", "accolade", "accroche", "accuser", "acerbe", "achat", "acheter", "aciduler", "acier", "acompte", "acquérir", "acronyme", "acteur", "actif", "actuel", "adepte", "adéquat", "adhésif", "adjectif", "adjuger", "admettre", "admirer", "adopter", "adorer", "adoucir", "adresse", "adroit", "adulte", "adverbe", "aérer", "aéronef", "affaire", "affecter", "affiche", "affreux", "affubler", "agacer", "agencer", "agile", "agiter", "agrafer", "agréable", "agrume", "aider", "aiguille", "ailier", "aimable", "aisance", "ajouter", "ajuster", "alarmer", "alchimie", "alerte", "algèbre", "algue", "aliéner", "aliment", "alléger", "alliage", "allouer", "allumer", "alourdir", "alpaga", "altesse", "alvéole", "amateur", "ambigu", "ambre", "aménager", "amertume", "amidon", "amiral", "amorcer", "amour", "amovible", "amphibie", "ampleur", "amusant", "analyse", "anaphore", "anarchie", "anatomie", "ancien", "anéantir", "angle", "angoisse", "anguleux", "animal", "annexer", "annonce", "annuel", "anodin", "anomalie", "anonyme", "anormal", "antenne", "antidote", "anxieux", "apaiser", "apéritif", "aplanir", "apologie", "appareil", "appeler", "apporter", "appuyer", "aquarium", "aqueduc", "arbitre", "arbuste", "ardeur", "ardoise", "argent", "arlequin", "armature", "armement", "armoire", "armure", "arpenter", "arracher", "arriver", "arroser", "arsenic", "artériel", "article", "aspect", "asphalte", "aspirer", "assaut", "asservir", "assiette", "associer", "assurer", "asticot", "astre", "astuce", "atelier", "atome", "atrium", "atroce", "attaque", "attentif", "attirer", "attraper", "aubaine", "auberge", "audace", "audible", "augurer", "aurore", "automne", "autruche", "avaler", "avancer", "avarice", "avenir", "averse", "aveugle", "aviateur", "avide", "avion", "aviser", "avoine", "avouer", "avril", "axial", "axiome", "badge", "bafouer", "bagage", "baguette", "baignade", "balancer", "balcon", "baleine", "balisage", "bambin", "bancaire", "bandage", "banlieue", "bannière", "banquier", "barbier", "baril", "baron", "barque", "barrage", "bassin", "bastion", "bataille", "bateau", "batterie", "baudrier", "bavarder", "belette", "bélier", "belote", "bénéfice", "berceau", "berger", "berline", "bermuda", "besace", "besogne", "bétail", "beurre", "biberon", "bicycle", "bidule", "bijou", "bilan", "bilingue", "billard", "binaire", "biologie", "biopsie", "biotype", "biscuit", "bison", "bistouri", "bitume", "bizarre", "blafard", "blague", "blanchir", "blessant", "blinder", "blond", "bloquer", "blouson", "bobard", "bobine", "boire", "boiser", "bolide", "bonbon", "bondir", "bonheur", "bonifier", "bonus", "bordure", "borne", "botte", "boucle", "boueux", "bougie", "boulon", "bouquin", "bourse", "boussole", "boutique", "boxeur", "branche", "brasier", "brave", "brebis", "brèche", "breuvage", "bricoler", "brigade", "brillant", "brioche", "brique", "brochure", "broder", "bronzer", "brousse", "broyeur", "brume", "brusque", "brutal", "bruyant", "buffle", "buisson", "bulletin", "bureau", "burin", "bustier", "butiner", "butoir", "buvable", "buvette", "cabanon", "cabine", "cachette", "cadeau", "cadre", "caféine", "caillou", "caisson", "calculer", "calepin", "calibre", "calmer", "calomnie", "calvaire", "camarade", "caméra", "camion", "campagne", "canal", "caneton", "canon", "cantine", "canular", "capable", "caporal", "caprice", "capsule", "capter", "capuche", "carabine", "carbone", "caresser", "caribou", "carnage", "carotte", "carreau", "carton", "cascade", "casier", "casque", "cassure", "causer", "caution", "cavalier", "caverne", "caviar", "cédille", "ceinture", "céleste", "cellule", "cendrier", "censurer", "central", "cercle", "cérébral", "cerise", "cerner", "cerveau", "cesser", "chagrin", "chaise", "chaleur", "chambre", "chance", "chapitre", "charbon", "chasseur", "chaton", "chausson", "chavirer", "chemise", "chenille", "chéquier", "chercher", "cheval", "chien", "chiffre", "chignon", "chimère", "chiot", "chlorure", "chocolat", "choisir", "chose", "chouette", "chrome", "chute", "cigare", "cigogne", "cimenter", "cinéma", "cintrer", "circuler", "cirer", "cirque", "citerne", "citoyen", "citron", "civil", "clairon", "clameur", "claquer", "classe", "clavier", "client", "cligner", "climat", "clivage", "cloche", "clonage", "cloporte", "cobalt", "cobra", "cocasse", "cocotier", "coder", "codifier", "coffre", "cogner", "cohésion", "coiffer", "coincer", "colère", "colibri", "colline", "colmater", "colonel", "combat", "comédie", "commande", "compact", "concert", "conduire", "confier", "congeler", "connoter", "consonne", "contact", "convexe", "copain", "copie", "corail", "corbeau", "cordage", "corniche", "corpus", "correct", "cortège", "cosmique", "costume", "coton", "coude", "coupure", "courage", "couteau", "couvrir", "coyote", "crabe", "crainte", "cravate", "crayon", "créature", "créditer", "crémeux", "creuser", "crevette", "cribler", "crier", "cristal", "critère", "croire", "croquer", "crotale", "crucial", "cruel", "crypter", "cubique", "cueillir", "cuillère", "cuisine", "cuivre", "culminer", "cultiver", "cumuler", "cupide", "curatif", "curseur", "cyanure", "cycle", "cylindre", "cynique", "daigner", "damier", "danger", "danseur", "dauphin", "débattre", "débiter", "déborder", "débrider", "débutant", "décaler", "décembre", "déchirer", "décider", "déclarer", "décorer", "décrire", "décupler", "dédale", "déductif", "déesse", "défensif", "défiler", "défrayer", "dégager", "dégivrer", "déglutir", "dégrafer", "déjeuner", "délice", "déloger", "demander", "demeurer", "démolir", "dénicher", "dénouer", "dentelle", "dénuder", "départ", "dépenser", "déphaser", "déplacer", "déposer", "déranger", "dérober", "désastre", "descente", "désert", "désigner", "désobéir", "dessiner", "destrier", "détacher", "détester", "détourer", "détresse", "devancer", "devenir", "deviner", "devoir", "diable", "dialogue", "diamant", "dicter", "différer", "digérer", "digital", "digne", "diluer", "dimanche", "diminuer", "dioxyde", "directif", "diriger", "discuter", "disposer", "dissiper", "distance", "divertir", "diviser", "docile", "docteur", "dogme", "doigt", "domaine", "domicile", "dompter", "donateur", "donjon", "donner", "dopamine", "dortoir", "dorure", "dosage", "doseur", "dossier", "dotation", "douanier", "double", "douceur", "douter", "doyen", "dragon", "draper", "dresser", "dribbler", "droiture", "duperie", "duplexe", "durable", "durcir", "dynastie", "éblouir", "écarter", "écharpe", "échelle", "éclairer", "éclipse", "éclore", "écluse", "école", "économie", "écorce", "écouter", "écraser", "écrémer", "écrivain", "écrou", "écume", "écureuil", "édifier", "éduquer", "effacer", "effectif", "effigie", "effort", "effrayer", "effusion", "égaliser", "égarer", "éjecter", "élaborer", "élargir", "électron", "élégant", "éléphant", "élève", "éligible", "élitisme", "éloge", "élucider", "éluder", "emballer", "embellir", "embryon", "émeraude", "émission", "emmener", "émotion", "émouvoir", "empereur", "employer", "emporter", "emprise", "émulsion", "encadrer", "enchère", "enclave", "encoche", "endiguer", "endosser", "endroit", "enduire", "énergie", "enfance", "enfermer", "enfouir", "engager", "engin", "englober", "énigme", "enjamber", "enjeu", "enlever", "ennemi", "ennuyeux", "enrichir", "enrobage", "enseigne", "entasser", "entendre", "entier", "entourer", "entraver", "énumérer", "envahir", "enviable", "envoyer", "enzyme", "éolien", "épaissir", "épargne", "épatant", "épaule", "épicerie", "épidémie", "épier", "épilogue", "épine", "épisode", "épitaphe", "époque", "épreuve", "éprouver", "épuisant", "équerre", "équipe", "ériger", "érosion", "erreur", "éruption", "escalier", "espadon", "espèce", "espiègle", "espoir", "esprit", "esquiver", "essayer", "essence", "essieu", "essorer", "estime", "estomac", "estrade", "étagère", "étaler", "étanche", "étatique", "éteindre", "étendoir", "éternel", "éthanol", "éthique", "ethnie", "étirer", "étoffer", "étoile", "étonnant", "étourdir", "étrange", "étroit", "étude", "euphorie", "évaluer", "évasion", "éventail", "évidence", "éviter", "évolutif", "évoquer", "exact", "exagérer", "exaucer", "exceller", "excitant", "exclusif", "excuse", "exécuter", "exemple", "exercer", "exhaler", "exhorter", "exigence", "exiler", "exister", "exotique", "expédier", "explorer", "exposer", "exprimer", "exquis", "extensif", "extraire", "exulter", "fable", "fabuleux", "facette", "facile", "facture", "faiblir", "falaise", "fameux", "famille", "farceur", "farfelu", "farine", "farouche", "fasciner", "fatal", "fatigue", "faucon", "fautif", "faveur", "favori", "fébrile", "féconder", "fédérer", "félin", "femme", "fémur", "fendoir", "féodal", "fermer", "féroce", "ferveur", "festival", "feuille", "feutre", "février", "fiasco", "ficeler", "fictif", "fidèle", "figure", "filature", "filetage", "filière", "filleul", "filmer", "filou", "filtrer", "financer", "finir", "fiole", "firme", "fissure", "fixer", "flairer", "flamme", "flasque", "flatteur", "fléau", "flèche", "fleur", "flexion", "flocon", "flore", "fluctuer", "fluide", "fluvial", "folie", "fonderie", "fongible", "fontaine", "forcer", "forgeron", "formuler", "fortune", "fossile", "foudre", "fougère", "fouiller", "foulure", "fourmi", "fragile", "fraise", "franchir", "frapper", "frayeur", "frégate", "freiner", "frelon", "frémir", "frénésie", "frère", "friable", "friction", "frisson", "frivole", "froid", "fromage", "frontal", "frotter", "fruit", "fugitif", "fuite", "fureur", "furieux", "furtif", "fusion", "futur", "gagner", "galaxie", "galerie", "gambader", "garantir", "gardien", "garnir", "garrigue", "gazelle", "gazon", "géant", "gélatine", "gélule", "gendarme", "général", "génie", "genou", "gentil", "géologie", "géomètre", "géranium", "germe", "gestuel", "geyser", "gibier", "gicler", "girafe", "givre", "glace", "glaive", "glisser", "globe", "gloire", "glorieux", "golfeur", "gomme", "gonfler", "gorge", "gorille", "goudron", "gouffre", "goulot", "goupille", "gourmand", "goutte", "graduel", "graffiti", "graine", "grand", "grappin", "gratuit", "gravir", "grenat", "griffure", "griller", "grimper", "grogner", "gronder", "grotte", "groupe", "gruger", "grutier", "gruyère", "guépard", "guerrier", "guide", "guimauve", "guitare", "gustatif", "gymnaste", "gyrostat", "habitude", "hachoir", "halte", "hameau", "hangar", "hanneton", "haricot", "harmonie", "harpon", "hasard", "hélium", "hématome", "herbe", "hérisson", "hermine", "héron", "hésiter", "heureux", "hiberner", "hibou", "hilarant", "histoire", "hiver", "homard", "hommage", "homogène", "honneur", "honorer", "honteux", "horde", "horizon", "horloge", "hormone", "horrible", "houleux", "housse", "hublot", "huileux", "humain", "humble", "humide", "humour", "hurler", "hydromel", "hygiène", "hymne", "hypnose", "idylle", "ignorer", "iguane", "illicite", "illusion", "image", "imbiber", "imiter", "immense", "immobile", "immuable", "impact", "impérial", "implorer", "imposer", "imprimer", "imputer", "incarner", "incendie", "incident", "incliner", "incolore", "indexer", "indice", "inductif", "inédit", "ineptie", "inexact", "infini", "infliger", "informer", "infusion", "ingérer", "inhaler", "inhiber", "injecter", "injure", "innocent", "inoculer", "inonder", "inscrire", "insecte", "insigne", "insolite", "inspirer", "instinct", "insulter", "intact", "intense", "intime", "intrigue", "intuitif", "inutile", "invasion", "inventer", "inviter", "invoquer", "ironique", "irradier", "irréel", "irriter", "isoler", "ivoire", "ivresse", "jaguar", "jaillir", "jambe", "janvier", "jardin", "jauger", "jaune", "javelot", "jetable", "jeton", "jeudi", "jeunesse", "joindre", "joncher", "jongler", "joueur", "jouissif", "journal", "jovial", "joyau", "joyeux", "jubiler", "jugement", "junior", "jupon", "juriste", "justice", "juteux", "juvénile", "kayak", "kimono", "kiosque", "label", "labial", "labourer", "lacérer", "lactose", "lagune", "laine", "laisser", "laitier", "lambeau", "lamelle", "lampe", "lanceur", "langage", "lanterne", "lapin", "largeur", "larme", "laurier", "lavabo", "lavoir", "lecture", "légal", "léger", "légume", "lessive", "lettre", "levier", "lexique", "lézard", "liasse", "libérer", "libre", "licence", "licorne", "liège", "lièvre", "ligature", "ligoter", "ligue", "limer", "limite", "limonade", "limpide", "linéaire", "lingot", "lionceau", "liquide", "lisière", "lister", "lithium", "litige", "littoral", "livreur", "logique", "lointain", "loisir", "lombric", "loterie", "louer", "lourd", "loutre", "louve", "loyal", "lubie", "lucide", "lucratif", "lueur", "lugubre", "luisant", "lumière", "lunaire", "lundi", "luron", "lutter", "luxueux", "machine", "magasin", "magenta", "magique", "maigre", "maillon", "maintien", "mairie", "maison", "majorer", "malaxer", "maléfice", "malheur", "malice", "mallette", "mammouth", "mandater", "maniable", "manquant", "manteau", "manuel", "marathon", "marbre", "marchand", "mardi", "maritime", "marqueur", "marron", "marteler", "mascotte", "massif", "matériel", "matière", "matraque", "maudire", "maussade", "mauve", "maximal", "méchant", "méconnu", "médaille", "médecin", "méditer", "méduse", "meilleur", "mélange", "mélodie", "membre", "mémoire", "menacer", "mener", "menhir", "mensonge", "mentor", "mercredi", "mérite", "merle", "messager", "mesure", "métal", "météore", "méthode", "métier", "meuble", "miauler", "microbe", "miette", "mignon", "migrer", "milieu", "million", "mimique", "mince", "minéral", "minimal", "minorer", "minute", "miracle", "miroiter", "missile", "mixte", "mobile", "moderne", "moelleux", "mondial", "moniteur", "monnaie", "monotone", "monstre", "montagne", "monument", "moqueur", "morceau", "morsure", "mortier", "moteur", "motif", "mouche", "moufle", "moulin", "mousson", "mouton", "mouvant", "multiple", "munition", "muraille", "murène", "murmure", "muscle", "muséum", "musicien", "mutation", "muter", "mutuel", "myriade", "myrtille", "mystère", "mythique", "nageur", "nappe", "narquois", "narrer", "natation", "nation", "nature", "naufrage", "nautique", "navire", "nébuleux", "nectar", "néfaste", "négation", "négliger", "négocier", "neige", "nerveux", "nettoyer", "neurone", "neutron", "neveu", "niche", "nickel", "nitrate", "niveau", "noble", "nocif", "nocturne", "noirceur", "noisette", "nomade", "nombreux", "nommer", "normatif", "notable", "notifier", "notoire", "nourrir", "nouveau", "novateur", "novembre", "novice", "nuage", "nuancer", "nuire", "nuisible", "numéro", "nuptial", "nuque", "nutritif", "obéir", "objectif", "obliger", "obscur", "observer", "obstacle", "obtenir", "obturer", "occasion", "occuper", "océan", "octobre", "octroyer", "octupler", "oculaire", "odeur", "odorant", "offenser", "officier", "offrir", "ogive", "oiseau", "oisillon", "olfactif", "olivier", "ombrage", "omettre", "onctueux", "onduler", "onéreux", "onirique", "opale", "opaque", "opérer", "opinion", "opportun", "opprimer", "opter", "optique", "orageux", "orange", "orbite", "ordonner", "oreille", "organe", "orgueil", "orifice", "ornement", "orque", "ortie", "osciller", "osmose", "ossature", "otarie", "ouragan", "ourson", "outil", "outrager", "ouvrage", "ovation", "oxyde", "oxygène", "ozone", "paisible", "palace", "palmarès", "palourde", "palper", "panache", "panda", "pangolin", "paniquer", "panneau", "panorama", "pantalon", "papaye", "papier", "papoter", "papyrus", "paradoxe", "parcelle", "paresse", "parfumer", "parler", "parole", "parrain", "parsemer", "partager", "parure", "parvenir", "passion", "pastèque", "paternel", "patience", "patron", "pavillon", "pavoiser", "payer", "paysage", "peigne", "peintre", "pelage", "pélican", "pelle", "pelouse", "peluche", "pendule", "pénétrer", "pénible", "pensif", "pénurie", "pépite", "péplum", "perdrix", "perforer", "période", "permuter", "perplexe", "persil", "perte", "peser", "pétale", "petit", "pétrir", "peuple", "pharaon", "phobie", "phoque", "photon", "phrase", "physique", "piano", "pictural", "pièce", "pierre", "pieuvre", "pilote", "pinceau", "pipette", "piquer", "pirogue", "piscine", "piston", "pivoter", "pixel", "pizza", "placard", "plafond", "plaisir", "planer", "plaque", "plastron", "plateau", "pleurer", "plexus", "pliage", "plomb", "plonger", "pluie", "plumage", "pochette", "poésie", "poète", "pointe", "poirier", "poisson", "poivre", "polaire", "policier", "pollen", "polygone", "pommade", "pompier", "ponctuel", "pondérer", "poney", "portique", "position", "posséder", "posture", "potager", "poteau", "potion", "pouce", "poulain", "poumon", "pourpre", "poussin", "pouvoir", "prairie", "pratique", "précieux", "prédire", "préfixe", "prélude", "prénom", "présence", "prétexte", "prévoir", "primitif", "prince", "prison", "priver", "problème", "procéder", "prodige", "profond", "progrès", "proie", "projeter", "prologue", "promener", "propre", "prospère", "protéger", "prouesse", "proverbe", "prudence", "pruneau", "psychose", "public", "puceron", "puiser", "pulpe", "pulsar", "punaise", "punitif", "pupitre", "purifier", "puzzle", "pyramide", "quasar", "querelle", "question", "quiétude", "quitter", "quotient", "racine", "raconter", "radieux", "ragondin", "raideur", "raisin", "ralentir", "rallonge", "ramasser", "rapide", "rasage", "ratisser", "ravager", "ravin", "rayonner", "réactif", "réagir", "réaliser", "réanimer", "recevoir", "réciter", "réclamer", "récolter", "recruter", "reculer", "recycler", "rédiger", "redouter", "refaire", "réflexe", "réformer", "refrain", "refuge", "régalien", "région", "réglage", "régulier", "réitérer", "rejeter", "rejouer", "relatif", "relever", "relief", "remarque", "remède", "remise", "remonter", "remplir", "remuer", "renard", "renfort", "renifler", "renoncer", "rentrer", "renvoi", "replier", "reporter", "reprise", "reptile", "requin", "réserve", "résineux", "résoudre", "respect", "rester", "résultat", "rétablir", "retenir", "réticule", "retomber", "retracer", "réunion", "réussir", "revanche", "revivre", "révolte", "révulsif", "richesse", "rideau", "rieur", "rigide", "rigoler", "rincer", "riposter", "risible", "risque", "rituel", "rival", "rivière", "rocheux", "romance", "rompre", "ronce", "rondin", "roseau", "rosier", "rotatif", "rotor", "rotule", "rouge", "rouille", "rouleau", "routine", "royaume", "ruban", "rubis", "ruche", "ruelle", "rugueux", "ruiner", "ruisseau", "ruser", "rustique", "rythme", "sabler", "saboter", "sabre", "sacoche", "safari", "sagesse", "saisir", "salade", "salive", "salon", "saluer", "samedi", "sanction", "sanglier", "sarcasme", "sardine", "saturer", "saugrenu", "saumon", "sauter", "sauvage", "savant", "savonner", "scalpel", "scandale", "scélérat", "scénario", "sceptre", "schéma", "science", "scinder", "score", "scrutin", "sculpter", "séance", "sécable", "sécher", "secouer", "sécréter", "sédatif", "séduire", "seigneur", "séjour", "sélectif", "semaine", "sembler", "semence", "séminal", "sénateur", "sensible", "sentence", "séparer", "séquence", "serein", "sergent", "sérieux", "serrure", "sérum", "service", "sésame", "sévir", "sevrage", "sextuple", "sidéral", "siècle", "siéger", "siffler", "sigle", "signal", "silence", "silicium", "simple", "sincère", "sinistre", "siphon", "sirop", "sismique", "situer", "skier", "social", "socle", "sodium", "soigneux", "soldat", "soleil", "solitude", "soluble", "sombre", "sommeil", "somnoler", "sonde", "songeur", "sonnette", "sonore", "sorcier", "sortir", "sosie", "sottise", "soucieux", "soudure", "souffle", "soulever", "soupape", "source", "soutirer", "souvenir", "spacieux", "spatial", "spécial", "sphère", "spiral", "stable", "station", "sternum", "stimulus", "stipuler", "strict", "studieux", "stupeur", "styliste", "sublime", "substrat", "subtil", "subvenir", "succès", "sucre", "suffixe", "suggérer", "suiveur", "sulfate", "superbe", "supplier", "surface", "suricate", "surmener", "surprise", "sursaut", "survie", "suspect", "syllabe", "symbole", "symétrie", "synapse", "syntaxe", "système", "tabac", "tablier", "tactile", "tailler", "talent", "talisman", "talonner", "tambour", "tamiser", "tangible", "tapis", "taquiner", "tarder", "tarif", "tartine", "tasse", "tatami", "tatouage", "taupe", "taureau", "taxer", "témoin", "temporel", "tenaille", "tendre", "teneur", "tenir", "tension", "terminer", "terne", "terrible", "tétine", "texte", "thème", "théorie", "thérapie", "thorax", "tibia", "tiède", "timide", "tirelire", "tiroir", "tissu", "titane", "titre", "tituber", "toboggan", "tolérant", "tomate", "tonique", "tonneau", "toponyme", "torche", "tordre", "tornade", "torpille", "torrent", "torse", "tortue", "totem", "toucher", "tournage", "tousser", "toxine", "traction", "trafic", "tragique", "trahir", "train", "trancher", "travail", "trèfle", "tremper", "trésor", "treuil", "triage", "tribunal", "tricoter", "trilogie", "triomphe", "tripler", "triturer", "trivial", "trombone", "tronc", "tropical", "troupeau", "tuile", "tulipe", "tumulte", "tunnel", "turbine", "tuteur", "tutoyer", "tuyau", "tympan", "typhon", "typique", "tyran", "ubuesque", "ultime", "ultrason", "unanime", "unifier", "union", "unique", "unitaire", "univers", "uranium", "urbain", "urticant", "usage", "usine", "usuel", "usure", "utile", "utopie", "vacarme", "vaccin", "vagabond", "vague", "vaillant", "vaincre", "vaisseau", "valable", "valise", "vallon", "valve", "vampire", "vanille", "vapeur", "varier", "vaseux", "vassal", "vaste", "vecteur", "vedette", "végétal", "véhicule", "veinard", "véloce", "vendredi", "vénérer", "venger", "venimeux", "ventouse", "verdure", "vérin", "vernir", "verrou", "verser", "vertu", "veston", "vétéran", "vétuste", "vexant", "vexer", "viaduc", "viande", "victoire", "vidange", "vidéo", "vignette", "vigueur", "vilain", "village", "vinaigre", "violon", "vipère", "virement", "virtuose", "virus", "visage", "viseur", "vision", "visqueux", "visuel", "vital", "vitesse", "viticole", "vitrine", "vivace", "vivipare", "vocation", "voguer", "voile", "voisin", "voiture", "volaille", "volcan", "voltiger", "volume", "vorace", "vortex", "voter", "vouloir", "voyage", "voyelle", "wagon", "xénon", "yacht", "zèbre", "zénith", "zeste", "zoologie" }; } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/wordlists/Japanese.java ================================================ /* * BIP39 library, a Java implementation of BIP39 * Copyright (C) 2017 Alan Evans, NovaCrypto * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Original source: https://github.com/NovaCrypto/BIP39 * You can contact the authors via github issues. */ package com.quincysx.crypto.bip39.wordlists; import com.quincysx.crypto.bip39.WordList; /** * Source: https://github.com/bitcoin/bips/blob/master/bip-0039/japanese.txt */ public enum Japanese implements WordList { INSTANCE; @Override public String getWord(final int index) { return words[index]; } @Override public int getIndex(final String word) { int size = words.length; if (word == null) { for (int i = 0; i < size; i++) if (words[i] == null) return i; } else { for (int i = 0; i < size; i++) if (word.equals(words[i])) return i; } return -1; } @Override public char getSpace() { return '\u3000'; //IDEOGRAPHIC SPACE } private final static String[] words = new String[]{ "あいこくしん", "あいさつ", "あいだ", "あおぞら", "あかちゃん", "あきる", "あけがた", "あける", "あこがれる", "あさい", "あさひ", "あしあと", "あじわう", "あずかる", "あずき", "あそぶ", "あたえる", "あたためる", "あたりまえ", "あたる", "あつい", "あつかう", "あっしゅく", "あつまり", "あつめる", "あてな", "あてはまる", "あひる", "あぶら", "あぶる", "あふれる", "あまい", "あまど", "あまやかす", "あまり", "あみもの", "あめりか", "あやまる", "あゆむ", "あらいぐま", "あらし", "あらすじ", "あらためる", "あらゆる", "あらわす", "ありがとう", "あわせる", "あわてる", "あんい", "あんがい", "あんこ", "あんぜん", "あんてい", "あんない", "あんまり", "いいだす", "いおん", "いがい", "いがく", "いきおい", "いきなり", "いきもの", "いきる", "いくじ", "いくぶん", "いけばな", "いけん", "いこう", "いこく", "いこつ", "いさましい", "いさん", "いしき", "いじゅう", "いじょう", "いじわる", "いずみ", "いずれ", "いせい", "いせえび", "いせかい", "いせき", "いぜん", "いそうろう", "いそがしい", "いだい", "いだく", "いたずら", "いたみ", "いたりあ", "いちおう", "いちじ", "いちど", "いちば", "いちぶ", "いちりゅう", "いつか", "いっしゅん", "いっせい", "いっそう", "いったん", "いっち", "いってい", "いっぽう", "いてざ", "いてん", "いどう", "いとこ", "いない", "いなか", "いねむり", "いのち", "いのる", "いはつ", "いばる", "いはん", "いびき", "いひん", "いふく", "いへん", "いほう", "いみん", "いもうと", "いもたれ", "いもり", "いやがる", "いやす", "いよかん", "いよく", "いらい", "いらすと", "いりぐち", "いりょう", "いれい", "いれもの", "いれる", "いろえんぴつ", "いわい", "いわう", "いわかん", "いわば", "いわゆる", "いんげんまめ", "いんさつ", "いんしょう", "いんよう", "うえき", "うえる", "うおざ", "うがい", "うかぶ", "うかべる", "うきわ", "うくらいな", "うくれれ", "うけたまわる", "うけつけ", "うけとる", "うけもつ", "うける", "うごかす", "うごく", "うこん", "うさぎ", "うしなう", "うしろがみ", "うすい", "うすぎ", "うすぐらい", "うすめる", "うせつ", "うちあわせ", "うちがわ", "うちき", "うちゅう", "うっかり", "うつくしい", "うったえる", "うつる", "うどん", "うなぎ", "うなじ", "うなずく", "うなる", "うねる", "うのう", "うぶげ", "うぶごえ", "うまれる", "うめる", "うもう", "うやまう", "うよく", "うらがえす", "うらぐち", "うらない", "うりあげ", "うりきれ", "うるさい", "うれしい", "うれゆき", "うれる", "うろこ", "うわき", "うわさ", "うんこう", "うんちん", "うんてん", "うんどう", "えいえん", "えいが", "えいきょう", "えいご", "えいせい", "えいぶん", "えいよう", "えいわ", "えおり", "えがお", "えがく", "えきたい", "えくせる", "えしゃく", "えすて", "えつらん", "えのぐ", "えほうまき", "えほん", "えまき", "えもじ", "えもの", "えらい", "えらぶ", "えりあ", "えんえん", "えんかい", "えんぎ", "えんげき", "えんしゅう", "えんぜつ", "えんそく", "えんちょう", "えんとつ", "おいかける", "おいこす", "おいしい", "おいつく", "おうえん", "おうさま", "おうじ", "おうせつ", "おうたい", "おうふく", "おうべい", "おうよう", "おえる", "おおい", "おおう", "おおどおり", "おおや", "おおよそ", "おかえり", "おかず", "おがむ", "おかわり", "おぎなう", "おきる", "おくさま", "おくじょう", "おくりがな", "おくる", "おくれる", "おこす", "おこなう", "おこる", "おさえる", "おさない", "おさめる", "おしいれ", "おしえる", "おじぎ", "おじさん", "おしゃれ", "おそらく", "おそわる", "おたがい", "おたく", "おだやか", "おちつく", "おっと", "おつり", "おでかけ", "おとしもの", "おとなしい", "おどり", "おどろかす", "おばさん", "おまいり", "おめでとう", "おもいで", "おもう", "おもたい", "おもちゃ", "おやつ", "おやゆび", "およぼす", "おらんだ", "おろす", "おんがく", "おんけい", "おんしゃ", "おんせん", "おんだん", "おんちゅう", "おんどけい", "かあつ", "かいが", "がいき", "がいけん", "がいこう", "かいさつ", "かいしゃ", "かいすいよく", "かいぜん", "かいぞうど", "かいつう", "かいてん", "かいとう", "かいふく", "がいへき", "かいほう", "かいよう", "がいらい", "かいわ", "かえる", "かおり", "かかえる", "かがく", "かがし", "かがみ", "かくご", "かくとく", "かざる", "がぞう", "かたい", "かたち", "がちょう", "がっきゅう", "がっこう", "がっさん", "がっしょう", "かなざわし", "かのう", "がはく", "かぶか", "かほう", "かほご", "かまう", "かまぼこ", "かめれおん", "かゆい", "かようび", "からい", "かるい", "かろう", "かわく", "かわら", "がんか", "かんけい", "かんこう", "かんしゃ", "かんそう", "かんたん", "かんち", "がんばる", "きあい", "きあつ", "きいろ", "ぎいん", "きうい", "きうん", "きえる", "きおう", "きおく", "きおち", "きおん", "きかい", "きかく", "きかんしゃ", "ききて", "きくばり", "きくらげ", "きけんせい", "きこう", "きこえる", "きこく", "きさい", "きさく", "きさま", "きさらぎ", "ぎじかがく", "ぎしき", "ぎじたいけん", "ぎじにってい", "ぎじゅつしゃ", "きすう", "きせい", "きせき", "きせつ", "きそう", "きぞく", "きぞん", "きたえる", "きちょう", "きつえん", "ぎっちり", "きつつき", "きつね", "きてい", "きどう", "きどく", "きない", "きなが", "きなこ", "きぬごし", "きねん", "きのう", "きのした", "きはく", "きびしい", "きひん", "きふく", "きぶん", "きぼう", "きほん", "きまる", "きみつ", "きむずかしい", "きめる", "きもだめし", "きもち", "きもの", "きゃく", "きやく", "ぎゅうにく", "きよう", "きょうりゅう", "きらい", "きらく", "きりん", "きれい", "きれつ", "きろく", "ぎろん", "きわめる", "ぎんいろ", "きんかくじ", "きんじょ", "きんようび", "ぐあい", "くいず", "くうかん", "くうき", "くうぐん", "くうこう", "ぐうせい", "くうそう", "ぐうたら", "くうふく", "くうぼ", "くかん", "くきょう", "くげん", "ぐこう", "くさい", "くさき", "くさばな", "くさる", "くしゃみ", "くしょう", "くすのき", "くすりゆび", "くせげ", "くせん", "ぐたいてき", "くださる", "くたびれる", "くちこみ", "くちさき", "くつした", "ぐっすり", "くつろぐ", "くとうてん", "くどく", "くなん", "くねくね", "くのう", "くふう", "くみあわせ", "くみたてる", "くめる", "くやくしょ", "くらす", "くらべる", "くるま", "くれる", "くろう", "くわしい", "ぐんかん", "ぐんしょく", "ぐんたい", "ぐんて", "けあな", "けいかく", "けいけん", "けいこ", "けいさつ", "げいじゅつ", "けいたい", "げいのうじん", "けいれき", "けいろ", "けおとす", "けおりもの", "げきか", "げきげん", "げきだん", "げきちん", "げきとつ", "げきは", "げきやく", "げこう", "げこくじょう", "げざい", "けさき", "げざん", "けしき", "けしごむ", "けしょう", "げすと", "けたば", "けちゃっぷ", "けちらす", "けつあつ", "けつい", "けつえき", "けっこん", "けつじょ", "けっせき", "けってい", "けつまつ", "げつようび", "げつれい", "けつろん", "げどく", "けとばす", "けとる", "けなげ", "けなす", "けなみ", "けぬき", "げねつ", "けねん", "けはい", "げひん", "けぶかい", "げぼく", "けまり", "けみかる", "けむし", "けむり", "けもの", "けらい", "けろけろ", "けわしい", "けんい", "けんえつ", "けんお", "けんか", "げんき", "けんげん", "けんこう", "けんさく", "けんしゅう", "けんすう", "げんそう", "けんちく", "けんてい", "けんとう", "けんない", "けんにん", "げんぶつ", "けんま", "けんみん", "けんめい", "けんらん", "けんり", "こあくま", "こいぬ", "こいびと", "ごうい", "こうえん", "こうおん", "こうかん", "ごうきゅう", "ごうけい", "こうこう", "こうさい", "こうじ", "こうすい", "ごうせい", "こうそく", "こうたい", "こうちゃ", "こうつう", "こうてい", "こうどう", "こうない", "こうはい", "ごうほう", "ごうまん", "こうもく", "こうりつ", "こえる", "こおり", "ごかい", "ごがつ", "ごかん", "こくご", "こくさい", "こくとう", "こくない", "こくはく", "こぐま", "こけい", "こける", "ここのか", "こころ", "こさめ", "こしつ", "こすう", "こせい", "こせき", "こぜん", "こそだて", "こたい", "こたえる", "こたつ", "こちょう", "こっか", "こつこつ", "こつばん", "こつぶ", "こてい", "こてん", "ことがら", "ことし", "ことば", "ことり", "こなごな", "こねこね", "このまま", "このみ", "このよ", "ごはん", "こひつじ", "こふう", "こふん", "こぼれる", "ごまあぶら", "こまかい", "ごますり", "こまつな", "こまる", "こむぎこ", "こもじ", "こもち", "こもの", "こもん", "こやく", "こやま", "こゆう", "こゆび", "こよい", "こよう", "こりる", "これくしょん", "ころっけ", "こわもて", "こわれる", "こんいん", "こんかい", "こんき", "こんしゅう", "こんすい", "こんだて", "こんとん", "こんなん", "こんびに", "こんぽん", "こんまけ", "こんや", "こんれい", "こんわく", "ざいえき", "さいかい", "さいきん", "ざいげん", "ざいこ", "さいしょ", "さいせい", "ざいたく", "ざいちゅう", "さいてき", "ざいりょう", "さうな", "さかいし", "さがす", "さかな", "さかみち", "さがる", "さぎょう", "さくし", "さくひん", "さくら", "さこく", "さこつ", "さずかる", "ざせき", "さたん", "さつえい", "ざつおん", "ざっか", "ざつがく", "さっきょく", "ざっし", "さつじん", "ざっそう", "さつたば", "さつまいも", "さてい", "さといも", "さとう", "さとおや", "さとし", "さとる", "さのう", "さばく", "さびしい", "さべつ", "さほう", "さほど", "さます", "さみしい", "さみだれ", "さむけ", "さめる", "さやえんどう", "さゆう", "さよう", "さよく", "さらだ", "ざるそば", "さわやか", "さわる", "さんいん", "さんか", "さんきゃく", "さんこう", "さんさい", "ざんしょ", "さんすう", "さんせい", "さんそ", "さんち", "さんま", "さんみ", "さんらん", "しあい", "しあげ", "しあさって", "しあわせ", "しいく", "しいん", "しうち", "しえい", "しおけ", "しかい", "しかく", "じかん", "しごと", "しすう", "じだい", "したうけ", "したぎ", "したて", "したみ", "しちょう", "しちりん", "しっかり", "しつじ", "しつもん", "してい", "してき", "してつ", "じてん", "じどう", "しなぎれ", "しなもの", "しなん", "しねま", "しねん", "しのぐ", "しのぶ", "しはい", "しばかり", "しはつ", "しはらい", "しはん", "しひょう", "しふく", "じぶん", "しへい", "しほう", "しほん", "しまう", "しまる", "しみん", "しむける", "じむしょ", "しめい", "しめる", "しもん", "しゃいん", "しゃうん", "しゃおん", "じゃがいも", "しやくしょ", "しゃくほう", "しゃけん", "しゃこ", "しゃざい", "しゃしん", "しゃせん", "しゃそう", "しゃたい", "しゃちょう", "しゃっきん", "じゃま", "しゃりん", "しゃれい", "じゆう", "じゅうしょ", "しゅくはく", "じゅしん", "しゅっせき", "しゅみ", "しゅらば", "じゅんばん", "しょうかい", "しょくたく", "しょっけん", "しょどう", "しょもつ", "しらせる", "しらべる", "しんか", "しんこう", "じんじゃ", "しんせいじ", "しんちく", "しんりん", "すあげ", "すあし", "すあな", "ずあん", "すいえい", "すいか", "すいとう", "ずいぶん", "すいようび", "すうがく", "すうじつ", "すうせん", "すおどり", "すきま", "すくう", "すくない", "すける", "すごい", "すこし", "ずさん", "すずしい", "すすむ", "すすめる", "すっかり", "ずっしり", "ずっと", "すてき", "すてる", "すねる", "すのこ", "すはだ", "すばらしい", "ずひょう", "ずぶぬれ", "すぶり", "すふれ", "すべて", "すべる", "ずほう", "すぼん", "すまい", "すめし", "すもう", "すやき", "すらすら", "するめ", "すれちがう", "すろっと", "すわる", "すんぜん", "すんぽう", "せあぶら", "せいかつ", "せいげん", "せいじ", "せいよう", "せおう", "せかいかん", "せきにん", "せきむ", "せきゆ", "せきらんうん", "せけん", "せこう", "せすじ", "せたい", "せたけ", "せっかく", "せっきゃく", "ぜっく", "せっけん", "せっこつ", "せっさたくま", "せつぞく", "せつだん", "せつでん", "せっぱん", "せつび", "せつぶん", "せつめい", "せつりつ", "せなか", "せのび", "せはば", "せびろ", "せぼね", "せまい", "せまる", "せめる", "せもたれ", "せりふ", "ぜんあく", "せんい", "せんえい", "せんか", "せんきょ", "せんく", "せんげん", "ぜんご", "せんさい", "せんしゅ", "せんすい", "せんせい", "せんぞ", "せんたく", "せんちょう", "せんてい", "せんとう", "せんぬき", "せんねん", "せんぱい", "ぜんぶ", "ぜんぽう", "せんむ", "せんめんじょ", "せんもん", "せんやく", "せんゆう", "せんよう", "ぜんら", "ぜんりゃく", "せんれい", "せんろ", "そあく", "そいとげる", "そいね", "そうがんきょう", "そうき", "そうご", "そうしん", "そうだん", "そうなん", "そうび", "そうめん", "そうり", "そえもの", "そえん", "そがい", "そげき", "そこう", "そこそこ", "そざい", "そしな", "そせい", "そせん", "そそぐ", "そだてる", "そつう", "そつえん", "そっかん", "そつぎょう", "そっけつ", "そっこう", "そっせん", "そっと", "そとがわ", "そとづら", "そなえる", "そなた", "そふぼ", "そぼく", "そぼろ", "そまつ", "そまる", "そむく", "そむりえ", "そめる", "そもそも", "そよかぜ", "そらまめ", "そろう", "そんかい", "そんけい", "そんざい", "そんしつ", "そんぞく", "そんちょう", "ぞんび", "ぞんぶん", "そんみん", "たあい", "たいいん", "たいうん", "たいえき", "たいおう", "だいがく", "たいき", "たいぐう", "たいけん", "たいこ", "たいざい", "だいじょうぶ", "だいすき", "たいせつ", "たいそう", "だいたい", "たいちょう", "たいてい", "だいどころ", "たいない", "たいねつ", "たいのう", "たいはん", "だいひょう", "たいふう", "たいへん", "たいほ", "たいまつばな", "たいみんぐ", "たいむ", "たいめん", "たいやき", "たいよう", "たいら", "たいりょく", "たいる", "たいわん", "たうえ", "たえる", "たおす", "たおる", "たおれる", "たかい", "たかね", "たきび", "たくさん", "たこく", "たこやき", "たさい", "たしざん", "だじゃれ", "たすける", "たずさわる", "たそがれ", "たたかう", "たたく", "ただしい", "たたみ", "たちばな", "だっかい", "だっきゃく", "だっこ", "だっしゅつ", "だったい", "たてる", "たとえる", "たなばた", "たにん", "たぬき", "たのしみ", "たはつ", "たぶん", "たべる", "たぼう", "たまご", "たまる", "だむる", "ためいき", "ためす", "ためる", "たもつ", "たやすい", "たよる", "たらす", "たりきほんがん", "たりょう", "たりる", "たると", "たれる", "たれんと", "たろっと", "たわむれる", "だんあつ", "たんい", "たんおん", "たんか", "たんき", "たんけん", "たんご", "たんさん", "たんじょうび", "だんせい", "たんそく", "たんたい", "だんち", "たんてい", "たんとう", "だんな", "たんにん", "だんねつ", "たんのう", "たんぴん", "だんぼう", "たんまつ", "たんめい", "だんれつ", "だんろ", "だんわ", "ちあい", "ちあん", "ちいき", "ちいさい", "ちえん", "ちかい", "ちから", "ちきゅう", "ちきん", "ちけいず", "ちけん", "ちこく", "ちさい", "ちしき", "ちしりょう", "ちせい", "ちそう", "ちたい", "ちたん", "ちちおや", "ちつじょ", "ちてき", "ちてん", "ちぬき", "ちぬり", "ちのう", "ちひょう", "ちへいせん", "ちほう", "ちまた", "ちみつ", "ちみどろ", "ちめいど", "ちゃんこなべ", "ちゅうい", "ちゆりょく", "ちょうし", "ちょさくけん", "ちらし", "ちらみ", "ちりがみ", "ちりょう", "ちるど", "ちわわ", "ちんたい", "ちんもく", "ついか", "ついたち", "つうか", "つうじょう", "つうはん", "つうわ", "つかう", "つかれる", "つくね", "つくる", "つけね", "つける", "つごう", "つたえる", "つづく", "つつじ", "つつむ", "つとめる", "つながる", "つなみ", "つねづね", "つのる", "つぶす", "つまらない", "つまる", "つみき", "つめたい", "つもり", "つもる", "つよい", "つるぼ", "つるみく", "つわもの", "つわり", "てあし", "てあて", "てあみ", "ていおん", "ていか", "ていき", "ていけい", "ていこく", "ていさつ", "ていし", "ていせい", "ていたい", "ていど", "ていねい", "ていひょう", "ていへん", "ていぼう", "てうち", "ておくれ", "てきとう", "てくび", "でこぼこ", "てさぎょう", "てさげ", "てすり", "てそう", "てちがい", "てちょう", "てつがく", "てつづき", "でっぱ", "てつぼう", "てつや", "でぬかえ", "てぬき", "てぬぐい", "てのひら", "てはい", "てぶくろ", "てふだ", "てほどき", "てほん", "てまえ", "てまきずし", "てみじか", "てみやげ", "てらす", "てれび", "てわけ", "てわたし", "でんあつ", "てんいん", "てんかい", "てんき", "てんぐ", "てんけん", "てんごく", "てんさい", "てんし", "てんすう", "でんち", "てんてき", "てんとう", "てんない", "てんぷら", "てんぼうだい", "てんめつ", "てんらんかい", "でんりょく", "でんわ", "どあい", "といれ", "どうかん", "とうきゅう", "どうぐ", "とうし", "とうむぎ", "とおい", "とおか", "とおく", "とおす", "とおる", "とかい", "とかす", "ときおり", "ときどき", "とくい", "とくしゅう", "とくてん", "とくに", "とくべつ", "とけい", "とける", "とこや", "とさか", "としょかん", "とそう", "とたん", "とちゅう", "とっきゅう", "とっくん", "とつぜん", "とつにゅう", "とどける", "ととのえる", "とない", "となえる", "となり", "とのさま", "とばす", "どぶがわ", "とほう", "とまる", "とめる", "ともだち", "ともる", "どようび", "とらえる", "とんかつ", "どんぶり", "ないかく", "ないこう", "ないしょ", "ないす", "ないせん", "ないそう", "なおす", "ながい", "なくす", "なげる", "なこうど", "なさけ", "なたでここ", "なっとう", "なつやすみ", "ななおし", "なにごと", "なにもの", "なにわ", "なのか", "なふだ", "なまいき", "なまえ", "なまみ", "なみだ", "なめらか", "なめる", "なやむ", "ならう", "ならび", "ならぶ", "なれる", "なわとび", "なわばり", "にあう", "にいがた", "にうけ", "におい", "にかい", "にがて", "にきび", "にくしみ", "にくまん", "にげる", "にさんかたんそ", "にしき", "にせもの", "にちじょう", "にちようび", "にっか", "にっき", "にっけい", "にっこう", "にっさん", "にっしょく", "にっすう", "にっせき", "にってい", "になう", "にほん", "にまめ", "にもつ", "にやり", "にゅういん", "にりんしゃ", "にわとり", "にんい", "にんか", "にんき", "にんげん", "にんしき", "にんずう", "にんそう", "にんたい", "にんち", "にんてい", "にんにく", "にんぷ", "にんまり", "にんむ", "にんめい", "にんよう", "ぬいくぎ", "ぬかす", "ぬぐいとる", "ぬぐう", "ぬくもり", "ぬすむ", "ぬまえび", "ぬめり", "ぬらす", "ぬんちゃく", "ねあげ", "ねいき", "ねいる", "ねいろ", "ねぐせ", "ねくたい", "ねくら", "ねこぜ", "ねこむ", "ねさげ", "ねすごす", "ねそべる", "ねだん", "ねつい", "ねっしん", "ねつぞう", "ねったいぎょ", "ねぶそく", "ねふだ", "ねぼう", "ねほりはほり", "ねまき", "ねまわし", "ねみみ", "ねむい", "ねむたい", "ねもと", "ねらう", "ねわざ", "ねんいり", "ねんおし", "ねんかん", "ねんきん", "ねんぐ", "ねんざ", "ねんし", "ねんちゃく", "ねんど", "ねんぴ", "ねんぶつ", "ねんまつ", "ねんりょう", "ねんれい", "のいず", "のおづま", "のがす", "のきなみ", "のこぎり", "のこす", "のこる", "のせる", "のぞく", "のぞむ", "のたまう", "のちほど", "のっく", "のばす", "のはら", "のべる", "のぼる", "のみもの", "のやま", "のらいぬ", "のらねこ", "のりもの", "のりゆき", "のれん", "のんき", "ばあい", "はあく", "ばあさん", "ばいか", "ばいく", "はいけん", "はいご", "はいしん", "はいすい", "はいせん", "はいそう", "はいち", "ばいばい", "はいれつ", "はえる", "はおる", "はかい", "ばかり", "はかる", "はくしゅ", "はけん", "はこぶ", "はさみ", "はさん", "はしご", "ばしょ", "はしる", "はせる", "ぱそこん", "はそん", "はたん", "はちみつ", "はつおん", "はっかく", "はづき", "はっきり", "はっくつ", "はっけん", "はっこう", "はっさん", "はっしん", "はったつ", "はっちゅう", "はってん", "はっぴょう", "はっぽう", "はなす", "はなび", "はにかむ", "はぶらし", "はみがき", "はむかう", "はめつ", "はやい", "はやし", "はらう", "はろうぃん", "はわい", "はんい", "はんえい", "はんおん", "はんかく", "はんきょう", "ばんぐみ", "はんこ", "はんしゃ", "はんすう", "はんだん", "ぱんち", "ぱんつ", "はんてい", "はんとし", "はんのう", "はんぱ", "はんぶん", "はんぺん", "はんぼうき", "はんめい", "はんらん", "はんろん", "ひいき", "ひうん", "ひえる", "ひかく", "ひかり", "ひかる", "ひかん", "ひくい", "ひけつ", "ひこうき", "ひこく", "ひさい", "ひさしぶり", "ひさん", "びじゅつかん", "ひしょ", "ひそか", "ひそむ", "ひたむき", "ひだり", "ひたる", "ひつぎ", "ひっこし", "ひっし", "ひつじゅひん", "ひっす", "ひつぜん", "ぴったり", "ぴっちり", "ひつよう", "ひてい", "ひとごみ", "ひなまつり", "ひなん", "ひねる", "ひはん", "ひびく", "ひひょう", "ひほう", "ひまわり", "ひまん", "ひみつ", "ひめい", "ひめじし", "ひやけ", "ひやす", "ひよう", "びょうき", "ひらがな", "ひらく", "ひりつ", "ひりょう", "ひるま", "ひるやすみ", "ひれい", "ひろい", "ひろう", "ひろき", "ひろゆき", "ひんかく", "ひんけつ", "ひんこん", "ひんしゅ", "ひんそう", "ぴんち", "ひんぱん", "びんぼう", "ふあん", "ふいうち", "ふうけい", "ふうせん", "ぷうたろう", "ふうとう", "ふうふ", "ふえる", "ふおん", "ふかい", "ふきん", "ふくざつ", "ふくぶくろ", "ふこう", "ふさい", "ふしぎ", "ふじみ", "ふすま", "ふせい", "ふせぐ", "ふそく", "ぶたにく", "ふたん", "ふちょう", "ふつう", "ふつか", "ふっかつ", "ふっき", "ふっこく", "ぶどう", "ふとる", "ふとん", "ふのう", "ふはい", "ふひょう", "ふへん", "ふまん", "ふみん", "ふめつ", "ふめん", "ふよう", "ふりこ", "ふりる", "ふるい", "ふんいき", "ぶんがく", "ぶんぐ", "ふんしつ", "ぶんせき", "ふんそう", "ぶんぽう", "へいあん", "へいおん", "へいがい", "へいき", "へいげん", "へいこう", "へいさ", "へいしゃ", "へいせつ", "へいそ", "へいたく", "へいてん", "へいねつ", "へいわ", "へきが", "へこむ", "べにいろ", "べにしょうが", "へらす", "へんかん", "べんきょう", "べんごし", "へんさい", "へんたい", "べんり", "ほあん", "ほいく", "ぼうぎょ", "ほうこく", "ほうそう", "ほうほう", "ほうもん", "ほうりつ", "ほえる", "ほおん", "ほかん", "ほきょう", "ぼきん", "ほくろ", "ほけつ", "ほけん", "ほこう", "ほこる", "ほしい", "ほしつ", "ほしゅ", "ほしょう", "ほせい", "ほそい", "ほそく", "ほたて", "ほたる", "ぽちぶくろ", "ほっきょく", "ほっさ", "ほったん", "ほとんど", "ほめる", "ほんい", "ほんき", "ほんけ", "ほんしつ", "ほんやく", "まいにち", "まかい", "まかせる", "まがる", "まける", "まこと", "まさつ", "まじめ", "ますく", "まぜる", "まつり", "まとめ", "まなぶ", "まぬけ", "まねく", "まほう", "まもる", "まゆげ", "まよう", "まろやか", "まわす", "まわり", "まわる", "まんが", "まんきつ", "まんぞく", "まんなか", "みいら", "みうち", "みえる", "みがく", "みかた", "みかん", "みけん", "みこん", "みじかい", "みすい", "みすえる", "みせる", "みっか", "みつかる", "みつける", "みてい", "みとめる", "みなと", "みなみかさい", "みねらる", "みのう", "みのがす", "みほん", "みもと", "みやげ", "みらい", "みりょく", "みわく", "みんか", "みんぞく", "むいか", "むえき", "むえん", "むかい", "むかう", "むかえ", "むかし", "むぎちゃ", "むける", "むげん", "むさぼる", "むしあつい", "むしば", "むじゅん", "むしろ", "むすう", "むすこ", "むすぶ", "むすめ", "むせる", "むせん", "むちゅう", "むなしい", "むのう", "むやみ", "むよう", "むらさき", "むりょう", "むろん", "めいあん", "めいうん", "めいえん", "めいかく", "めいきょく", "めいさい", "めいし", "めいそう", "めいぶつ", "めいれい", "めいわく", "めぐまれる", "めざす", "めした", "めずらしい", "めだつ", "めまい", "めやす", "めんきょ", "めんせき", "めんどう", "もうしあげる", "もうどうけん", "もえる", "もくし", "もくてき", "もくようび", "もちろん", "もどる", "もらう", "もんく", "もんだい", "やおや", "やける", "やさい", "やさしい", "やすい", "やすたろう", "やすみ", "やせる", "やそう", "やたい", "やちん", "やっと", "やっぱり", "やぶる", "やめる", "ややこしい", "やよい", "やわらかい", "ゆうき", "ゆうびんきょく", "ゆうべ", "ゆうめい", "ゆけつ", "ゆしゅつ", "ゆせん", "ゆそう", "ゆたか", "ゆちゃく", "ゆでる", "ゆにゅう", "ゆびわ", "ゆらい", "ゆれる", "ようい", "ようか", "ようきゅう", "ようじ", "ようす", "ようちえん", "よかぜ", "よかん", "よきん", "よくせい", "よくぼう", "よけい", "よごれる", "よさん", "よしゅう", "よそう", "よそく", "よっか", "よてい", "よどがわく", "よねつ", "よやく", "よゆう", "よろこぶ", "よろしい", "らいう", "らくがき", "らくご", "らくさつ", "らくだ", "らしんばん", "らせん", "らぞく", "らたい", "らっか", "られつ", "りえき", "りかい", "りきさく", "りきせつ", "りくぐん", "りくつ", "りけん", "りこう", "りせい", "りそう", "りそく", "りてん", "りねん", "りゆう", "りゅうがく", "りよう", "りょうり", "りょかん", "りょくちゃ", "りょこう", "りりく", "りれき", "りろん", "りんご", "るいけい", "るいさい", "るいじ", "るいせき", "るすばん", "るりがわら", "れいかん", "れいぎ", "れいせい", "れいぞうこ", "れいとう", "れいぼう", "れきし", "れきだい", "れんあい", "れんけい", "れんこん", "れんさい", "れんしゅう", "れんぞく", "れんらく", "ろうか", "ろうご", "ろうじん", "ろうそく", "ろくが", "ろこつ", "ろじうら", "ろしゅつ", "ろせん", "ろてん", "ろめん", "ろれつ", "ろんぎ", "ろんぱ", "ろんぶん", "ろんり", "わかす", "わかめ", "わかやま", "わかれる", "わしつ", "わじまし", "わすれもの", "わらう", "われる" }; } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip39/wordlists/Spanish.java ================================================ /* * BIP39 library, a Java implementation of BIP39 * Copyright (C) 2017 Alan Evans, NovaCrypto * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Original source: https://github.com/NovaCrypto/BIP39 * You can contact the authors via github issues. */ package com.quincysx.crypto.bip39.wordlists; import com.quincysx.crypto.bip39.WordList; /** * Source: https://github.com/bitcoin/bips/blob/master/bip-0039/spanish.txt */ public enum Spanish implements WordList { INSTANCE; @Override public String getWord(final int index) { return words[index]; } @Override public int getIndex(final String word) { int size = words.length; if (word == null) { for (int i = 0; i < size; i++) if (words[i] == null) return i; } else { for (int i = 0; i < size; i++) if (word.equals(words[i])) return i; } return -1; } @Override public char getSpace() { return ' '; } private final static String[] words = new String[]{ "ábaco", "abdomen", "abeja", "abierto", "abogado", "abono", "aborto", "abrazo", "abrir", "abuelo", "abuso", "acabar", "academia", "acceso", "acción", "aceite", "acelga", "acento", "aceptar", "ácido", "aclarar", "acné", "acoger", "acoso", "activo", "acto", "actriz", "actuar", "acudir", "acuerdo", "acusar", "adicto", "admitir", "adoptar", "adorno", "aduana", "adulto", "aéreo", "afectar", "afición", "afinar", "afirmar", "ágil", "agitar", "agonía", "agosto", "agotar", "agregar", "agrio", "agua", "agudo", "águila", "aguja", "ahogo", "ahorro", "aire", "aislar", "ajedrez", "ajeno", "ajuste", "alacrán", "alambre", "alarma", "alba", "álbum", "alcalde", "aldea", "alegre", "alejar", "alerta", "aleta", "alfiler", "alga", "algodón", "aliado", "aliento", "alivio", "alma", "almeja", "almíbar", "altar", "alteza", "altivo", "alto", "altura", "alumno", "alzar", "amable", "amante", "amapola", "amargo", "amasar", "ámbar", "ámbito", "ameno", "amigo", "amistad", "amor", "amparo", "amplio", "ancho", "anciano", "ancla", "andar", "andén", "anemia", "ángulo", "anillo", "ánimo", "anís", "anotar", "antena", "antiguo", "antojo", "anual", "anular", "anuncio", "añadir", "añejo", "año", "apagar", "aparato", "apetito", "apio", "aplicar", "apodo", "aporte", "apoyo", "aprender", "aprobar", "apuesta", "apuro", "arado", "araña", "arar", "árbitro", "árbol", "arbusto", "archivo", "arco", "arder", "ardilla", "arduo", "área", "árido", "aries", "armonía", "arnés", "aroma", "arpa", "arpón", "arreglo", "arroz", "arruga", "arte", "artista", "asa", "asado", "asalto", "ascenso", "asegurar", "aseo", "asesor", "asiento", "asilo", "asistir", "asno", "asombro", "áspero", "astilla", "astro", "astuto", "asumir", "asunto", "atajo", "ataque", "atar", "atento", "ateo", "ático", "atleta", "átomo", "atraer", "atroz", "atún", "audaz", "audio", "auge", "aula", "aumento", "ausente", "autor", "aval", "avance", "avaro", "ave", "avellana", "avena", "avestruz", "avión", "aviso", "ayer", "ayuda", "ayuno", "azafrán", "azar", "azote", "azúcar", "azufre", "azul", "baba", "babor", "bache", "bahía", "baile", "bajar", "balanza", "balcón", "balde", "bambú", "banco", "banda", "baño", "barba", "barco", "barniz", "barro", "báscula", "bastón", "basura", "batalla", "batería", "batir", "batuta", "baúl", "bazar", "bebé", "bebida", "bello", "besar", "beso", "bestia", "bicho", "bien", "bingo", "blanco", "bloque", "blusa", "boa", "bobina", "bobo", "boca", "bocina", "boda", "bodega", "boina", "bola", "bolero", "bolsa", "bomba", "bondad", "bonito", "bono", "bonsái", "borde", "borrar", "bosque", "bote", "botín", "bóveda", "bozal", "bravo", "brazo", "brecha", "breve", "brillo", "brinco", "brisa", "broca", "broma", "bronce", "brote", "bruja", "brusco", "bruto", "buceo", "bucle", "bueno", "buey", "bufanda", "bufón", "búho", "buitre", "bulto", "burbuja", "burla", "burro", "buscar", "butaca", "buzón", "caballo", "cabeza", "cabina", "cabra", "cacao", "cadáver", "cadena", "caer", "café", "caída", "caimán", "caja", "cajón", "cal", "calamar", "calcio", "caldo", "calidad", "calle", "calma", "calor", "calvo", "cama", "cambio", "camello", "camino", "campo", "cáncer", "candil", "canela", "canguro", "canica", "canto", "caña", "cañón", "caoba", "caos", "capaz", "capitán", "capote", "captar", "capucha", "cara", "carbón", "cárcel", "careta", "carga", "cariño", "carne", "carpeta", "carro", "carta", "casa", "casco", "casero", "caspa", "castor", "catorce", "catre", "caudal", "causa", "cazo", "cebolla", "ceder", "cedro", "celda", "célebre", "celoso", "célula", "cemento", "ceniza", "centro", "cerca", "cerdo", "cereza", "cero", "cerrar", "certeza", "césped", "cetro", "chacal", "chaleco", "champú", "chancla", "chapa", "charla", "chico", "chiste", "chivo", "choque", "choza", "chuleta", "chupar", "ciclón", "ciego", "cielo", "cien", "cierto", "cifra", "cigarro", "cima", "cinco", "cine", "cinta", "ciprés", "circo", "ciruela", "cisne", "cita", "ciudad", "clamor", "clan", "claro", "clase", "clave", "cliente", "clima", "clínica", "cobre", "cocción", "cochino", "cocina", "coco", "código", "codo", "cofre", "coger", "cohete", "cojín", "cojo", "cola", "colcha", "colegio", "colgar", "colina", "collar", "colmo", "columna", "combate", "comer", "comida", "cómodo", "compra", "conde", "conejo", "conga", "conocer", "consejo", "contar", "copa", "copia", "corazón", "corbata", "corcho", "cordón", "corona", "correr", "coser", "cosmos", "costa", "cráneo", "cráter", "crear", "crecer", "creído", "crema", "cría", "crimen", "cripta", "crisis", "cromo", "crónica", "croqueta", "crudo", "cruz", "cuadro", "cuarto", "cuatro", "cubo", "cubrir", "cuchara", "cuello", "cuento", "cuerda", "cuesta", "cueva", "cuidar", "culebra", "culpa", "culto", "cumbre", "cumplir", "cuna", "cuneta", "cuota", "cupón", "cúpula", "curar", "curioso", "curso", "curva", "cutis", "dama", "danza", "dar", "dardo", "dátil", "deber", "débil", "década", "decir", "dedo", "defensa", "definir", "dejar", "delfín", "delgado", "delito", "demora", "denso", "dental", "deporte", "derecho", "derrota", "desayuno", "deseo", "desfile", "desnudo", "destino", "desvío", "detalle", "detener", "deuda", "día", "diablo", "diadema", "diamante", "diana", "diario", "dibujo", "dictar", "diente", "dieta", "diez", "difícil", "digno", "dilema", "diluir", "dinero", "directo", "dirigir", "disco", "diseño", "disfraz", "diva", "divino", "doble", "doce", "dolor", "domingo", "don", "donar", "dorado", "dormir", "dorso", "dos", "dosis", "dragón", "droga", "ducha", "duda", "duelo", "dueño", "dulce", "dúo", "duque", "durar", "dureza", "duro", "ébano", "ebrio", "echar", "eco", "ecuador", "edad", "edición", "edificio", "editor", "educar", "efecto", "eficaz", "eje", "ejemplo", "elefante", "elegir", "elemento", "elevar", "elipse", "élite", "elixir", "elogio", "eludir", "embudo", "emitir", "emoción", "empate", "empeño", "empleo", "empresa", "enano", "encargo", "enchufe", "encía", "enemigo", "enero", "enfado", "enfermo", "engaño", "enigma", "enlace", "enorme", "enredo", "ensayo", "enseñar", "entero", "entrar", "envase", "envío", "época", "equipo", "erizo", "escala", "escena", "escolar", "escribir", "escudo", "esencia", "esfera", "esfuerzo", "espada", "espejo", "espía", "esposa", "espuma", "esquí", "estar", "este", "estilo", "estufa", "etapa", "eterno", "ética", "etnia", "evadir", "evaluar", "evento", "evitar", "exacto", "examen", "exceso", "excusa", "exento", "exigir", "exilio", "existir", "éxito", "experto", "explicar", "exponer", "extremo", "fábrica", "fábula", "fachada", "fácil", "factor", "faena", "faja", "falda", "fallo", "falso", "faltar", "fama", "familia", "famoso", "faraón", "farmacia", "farol", "farsa", "fase", "fatiga", "fauna", "favor", "fax", "febrero", "fecha", "feliz", "feo", "feria", "feroz", "fértil", "fervor", "festín", "fiable", "fianza", "fiar", "fibra", "ficción", "ficha", "fideo", "fiebre", "fiel", "fiera", "fiesta", "figura", "fijar", "fijo", "fila", "filete", "filial", "filtro", "fin", "finca", "fingir", "finito", "firma", "flaco", "flauta", "flecha", "flor", "flota", "fluir", "flujo", "flúor", "fobia", "foca", "fogata", "fogón", "folio", "folleto", "fondo", "forma", "forro", "fortuna", "forzar", "fosa", "foto", "fracaso", "frágil", "franja", "frase", "fraude", "freír", "freno", "fresa", "frío", "frito", "fruta", "fuego", "fuente", "fuerza", "fuga", "fumar", "función", "funda", "furgón", "furia", "fusil", "fútbol", "futuro", "gacela", "gafas", "gaita", "gajo", "gala", "galería", "gallo", "gamba", "ganar", "gancho", "ganga", "ganso", "garaje", "garza", "gasolina", "gastar", "gato", "gavilán", "gemelo", "gemir", "gen", "género", "genio", "gente", "geranio", "gerente", "germen", "gesto", "gigante", "gimnasio", "girar", "giro", "glaciar", "globo", "gloria", "gol", "golfo", "goloso", "golpe", "goma", "gordo", "gorila", "gorra", "gota", "goteo", "gozar", "grada", "gráfico", "grano", "grasa", "gratis", "grave", "grieta", "grillo", "gripe", "gris", "grito", "grosor", "grúa", "grueso", "grumo", "grupo", "guante", "guapo", "guardia", "guerra", "guía", "guiño", "guion", "guiso", "guitarra", "gusano", "gustar", "haber", "hábil", "hablar", "hacer", "hacha", "hada", "hallar", "hamaca", "harina", "haz", "hazaña", "hebilla", "hebra", "hecho", "helado", "helio", "hembra", "herir", "hermano", "héroe", "hervir", "hielo", "hierro", "hígado", "higiene", "hijo", "himno", "historia", "hocico", "hogar", "hoguera", "hoja", "hombre", "hongo", "honor", "honra", "hora", "hormiga", "horno", "hostil", "hoyo", "hueco", "huelga", "huerta", "hueso", "huevo", "huida", "huir", "humano", "húmedo", "humilde", "humo", "hundir", "huracán", "hurto", "icono", "ideal", "idioma", "ídolo", "iglesia", "iglú", "igual", "ilegal", "ilusión", "imagen", "imán", "imitar", "impar", "imperio", "imponer", "impulso", "incapaz", "índice", "inerte", "infiel", "informe", "ingenio", "inicio", "inmenso", "inmune", "innato", "insecto", "instante", "interés", "íntimo", "intuir", "inútil", "invierno", "ira", "iris", "ironía", "isla", "islote", "jabalí", "jabón", "jamón", "jarabe", "jardín", "jarra", "jaula", "jazmín", "jefe", "jeringa", "jinete", "jornada", "joroba", "joven", "joya", "juerga", "jueves", "juez", "jugador", "jugo", "juguete", "juicio", "junco", "jungla", "junio", "juntar", "júpiter", "jurar", "justo", "juvenil", "juzgar", "kilo", "koala", "labio", "lacio", "lacra", "lado", "ladrón", "lagarto", "lágrima", "laguna", "laico", "lamer", "lámina", "lámpara", "lana", "lancha", "langosta", "lanza", "lápiz", "largo", "larva", "lástima", "lata", "látex", "latir", "laurel", "lavar", "lazo", "leal", "lección", "leche", "lector", "leer", "legión", "legumbre", "lejano", "lengua", "lento", "leña", "león", "leopardo", "lesión", "letal", "letra", "leve", "leyenda", "libertad", "libro", "licor", "líder", "lidiar", "lienzo", "liga", "ligero", "lima", "límite", "limón", "limpio", "lince", "lindo", "línea", "lingote", "lino", "linterna", "líquido", "liso", "lista", "litera", "litio", "litro", "llaga", "llama", "llanto", "llave", "llegar", "llenar", "llevar", "llorar", "llover", "lluvia", "lobo", "loción", "loco", "locura", "lógica", "logro", "lombriz", "lomo", "lonja", "lote", "lucha", "lucir", "lugar", "lujo", "luna", "lunes", "lupa", "lustro", "luto", "luz", "maceta", "macho", "madera", "madre", "maduro", "maestro", "mafia", "magia", "mago", "maíz", "maldad", "maleta", "malla", "malo", "mamá", "mambo", "mamut", "manco", "mando", "manejar", "manga", "maniquí", "manjar", "mano", "manso", "manta", "mañana", "mapa", "máquina", "mar", "marco", "marea", "marfil", "margen", "marido", "mármol", "marrón", "martes", "marzo", "masa", "máscara", "masivo", "matar", "materia", "matiz", "matriz", "máximo", "mayor", "mazorca", "mecha", "medalla", "medio", "médula", "mejilla", "mejor", "melena", "melón", "memoria", "menor", "mensaje", "mente", "menú", "mercado", "merengue", "mérito", "mes", "mesón", "meta", "meter", "método", "metro", "mezcla", "miedo", "miel", "miembro", "miga", "mil", "milagro", "militar", "millón", "mimo", "mina", "minero", "mínimo", "minuto", "miope", "mirar", "misa", "miseria", "misil", "mismo", "mitad", "mito", "mochila", "moción", "moda", "modelo", "moho", "mojar", "molde", "moler", "molino", "momento", "momia", "monarca", "moneda", "monja", "monto", "moño", "morada", "morder", "moreno", "morir", "morro", "morsa", "mortal", "mosca", "mostrar", "motivo", "mover", "móvil", "mozo", "mucho", "mudar", "mueble", "muela", "muerte", "muestra", "mugre", "mujer", "mula", "muleta", "multa", "mundo", "muñeca", "mural", "muro", "músculo", "museo", "musgo", "música", "muslo", "nácar", "nación", "nadar", "naipe", "naranja", "nariz", "narrar", "nasal", "natal", "nativo", "natural", "náusea", "naval", "nave", "navidad", "necio", "néctar", "negar", "negocio", "negro", "neón", "nervio", "neto", "neutro", "nevar", "nevera", "nicho", "nido", "niebla", "nieto", "niñez", "niño", "nítido", "nivel", "nobleza", "noche", "nómina", "noria", "norma", "norte", "nota", "noticia", "novato", "novela", "novio", "nube", "nuca", "núcleo", "nudillo", "nudo", "nuera", "nueve", "nuez", "nulo", "número", "nutria", "oasis", "obeso", "obispo", "objeto", "obra", "obrero", "observar", "obtener", "obvio", "oca", "ocaso", "océano", "ochenta", "ocho", "ocio", "ocre", "octavo", "octubre", "oculto", "ocupar", "ocurrir", "odiar", "odio", "odisea", "oeste", "ofensa", "oferta", "oficio", "ofrecer", "ogro", "oído", "oír", "ojo", "ola", "oleada", "olfato", "olivo", "olla", "olmo", "olor", "olvido", "ombligo", "onda", "onza", "opaco", "opción", "ópera", "opinar", "oponer", "optar", "óptica", "opuesto", "oración", "orador", "oral", "órbita", "orca", "orden", "oreja", "órgano", "orgía", "orgullo", "oriente", "origen", "orilla", "oro", "orquesta", "oruga", "osadía", "oscuro", "osezno", "oso", "ostra", "otoño", "otro", "oveja", "óvulo", "óxido", "oxígeno", "oyente", "ozono", "pacto", "padre", "paella", "página", "pago", "país", "pájaro", "palabra", "palco", "paleta", "pálido", "palma", "paloma", "palpar", "pan", "panal", "pánico", "pantera", "pañuelo", "papá", "papel", "papilla", "paquete", "parar", "parcela", "pared", "parir", "paro", "párpado", "parque", "párrafo", "parte", "pasar", "paseo", "pasión", "paso", "pasta", "pata", "patio", "patria", "pausa", "pauta", "pavo", "payaso", "peatón", "pecado", "pecera", "pecho", "pedal", "pedir", "pegar", "peine", "pelar", "peldaño", "pelea", "peligro", "pellejo", "pelo", "peluca", "pena", "pensar", "peñón", "peón", "peor", "pepino", "pequeño", "pera", "percha", "perder", "pereza", "perfil", "perico", "perla", "permiso", "perro", "persona", "pesa", "pesca", "pésimo", "pestaña", "pétalo", "petróleo", "pez", "pezuña", "picar", "pichón", "pie", "piedra", "pierna", "pieza", "pijama", "pilar", "piloto", "pimienta", "pino", "pintor", "pinza", "piña", "piojo", "pipa", "pirata", "pisar", "piscina", "piso", "pista", "pitón", "pizca", "placa", "plan", "plata", "playa", "plaza", "pleito", "pleno", "plomo", "pluma", "plural", "pobre", "poco", "poder", "podio", "poema", "poesía", "poeta", "polen", "policía", "pollo", "polvo", "pomada", "pomelo", "pomo", "pompa", "poner", "porción", "portal", "posada", "poseer", "posible", "poste", "potencia", "potro", "pozo", "prado", "precoz", "pregunta", "premio", "prensa", "preso", "previo", "primo", "príncipe", "prisión", "privar", "proa", "probar", "proceso", "producto", "proeza", "profesor", "programa", "prole", "promesa", "pronto", "propio", "próximo", "prueba", "público", "puchero", "pudor", "pueblo", "puerta", "puesto", "pulga", "pulir", "pulmón", "pulpo", "pulso", "puma", "punto", "puñal", "puño", "pupa", "pupila", "puré", "quedar", "queja", "quemar", "querer", "queso", "quieto", "química", "quince", "quitar", "rábano", "rabia", "rabo", "ración", "radical", "raíz", "rama", "rampa", "rancho", "rango", "rapaz", "rápido", "rapto", "rasgo", "raspa", "rato", "rayo", "raza", "razón", "reacción", "realidad", "rebaño", "rebote", "recaer", "receta", "rechazo", "recoger", "recreo", "recto", "recurso", "red", "redondo", "reducir", "reflejo", "reforma", "refrán", "refugio", "regalo", "regir", "regla", "regreso", "rehén", "reino", "reír", "reja", "relato", "relevo", "relieve", "relleno", "reloj", "remar", "remedio", "remo", "rencor", "rendir", "renta", "reparto", "repetir", "reposo", "reptil", "res", "rescate", "resina", "respeto", "resto", "resumen", "retiro", "retorno", "retrato", "reunir", "revés", "revista", "rey", "rezar", "rico", "riego", "rienda", "riesgo", "rifa", "rígido", "rigor", "rincón", "riñón", "río", "riqueza", "risa", "ritmo", "rito", "rizo", "roble", "roce", "rociar", "rodar", "rodeo", "rodilla", "roer", "rojizo", "rojo", "romero", "romper", "ron", "ronco", "ronda", "ropa", "ropero", "rosa", "rosca", "rostro", "rotar", "rubí", "rubor", "rudo", "rueda", "rugir", "ruido", "ruina", "ruleta", "rulo", "rumbo", "rumor", "ruptura", "ruta", "rutina", "sábado", "saber", "sabio", "sable", "sacar", "sagaz", "sagrado", "sala", "saldo", "salero", "salir", "salmón", "salón", "salsa", "salto", "salud", "salvar", "samba", "sanción", "sandía", "sanear", "sangre", "sanidad", "sano", "santo", "sapo", "saque", "sardina", "sartén", "sastre", "satán", "sauna", "saxofón", "sección", "seco", "secreto", "secta", "sed", "seguir", "seis", "sello", "selva", "semana", "semilla", "senda", "sensor", "señal", "señor", "separar", "sepia", "sequía", "ser", "serie", "sermón", "servir", "sesenta", "sesión", "seta", "setenta", "severo", "sexo", "sexto", "sidra", "siesta", "siete", "siglo", "signo", "sílaba", "silbar", "silencio", "silla", "símbolo", "simio", "sirena", "sistema", "sitio", "situar", "sobre", "socio", "sodio", "sol", "solapa", "soldado", "soledad", "sólido", "soltar", "solución", "sombra", "sondeo", "sonido", "sonoro", "sonrisa", "sopa", "soplar", "soporte", "sordo", "sorpresa", "sorteo", "sostén", "sótano", "suave", "subir", "suceso", "sudor", "suegra", "suelo", "sueño", "suerte", "sufrir", "sujeto", "sultán", "sumar", "superar", "suplir", "suponer", "supremo", "sur", "surco", "sureño", "surgir", "susto", "sutil", "tabaco", "tabique", "tabla", "tabú", "taco", "tacto", "tajo", "talar", "talco", "talento", "talla", "talón", "tamaño", "tambor", "tango", "tanque", "tapa", "tapete", "tapia", "tapón", "taquilla", "tarde", "tarea", "tarifa", "tarjeta", "tarot", "tarro", "tarta", "tatuaje", "tauro", "taza", "tazón", "teatro", "techo", "tecla", "técnica", "tejado", "tejer", "tejido", "tela", "teléfono", "tema", "temor", "templo", "tenaz", "tender", "tener", "tenis", "tenso", "teoría", "terapia", "terco", "término", "ternura", "terror", "tesis", "tesoro", "testigo", "tetera", "texto", "tez", "tibio", "tiburón", "tiempo", "tienda", "tierra", "tieso", "tigre", "tijera", "tilde", "timbre", "tímido", "timo", "tinta", "tío", "típico", "tipo", "tira", "tirón", "titán", "títere", "título", "tiza", "toalla", "tobillo", "tocar", "tocino", "todo", "toga", "toldo", "tomar", "tono", "tonto", "topar", "tope", "toque", "tórax", "torero", "tormenta", "torneo", "toro", "torpedo", "torre", "torso", "tortuga", "tos", "tosco", "toser", "tóxico", "trabajo", "tractor", "traer", "tráfico", "trago", "traje", "tramo", "trance", "trato", "trauma", "trazar", "trébol", "tregua", "treinta", "tren", "trepar", "tres", "tribu", "trigo", "tripa", "triste", "triunfo", "trofeo", "trompa", "tronco", "tropa", "trote", "trozo", "truco", "trueno", "trufa", "tubería", "tubo", "tuerto", "tumba", "tumor", "túnel", "túnica", "turbina", "turismo", "turno", "tutor", "ubicar", "úlcera", "umbral", "unidad", "unir", "universo", "uno", "untar", "uña", "urbano", "urbe", "urgente", "urna", "usar", "usuario", "útil", "utopía", "uva", "vaca", "vacío", "vacuna", "vagar", "vago", "vaina", "vajilla", "vale", "válido", "valle", "valor", "válvula", "vampiro", "vara", "variar", "varón", "vaso", "vecino", "vector", "vehículo", "veinte", "vejez", "vela", "velero", "veloz", "vena", "vencer", "venda", "veneno", "vengar", "venir", "venta", "venus", "ver", "verano", "verbo", "verde", "vereda", "verja", "verso", "verter", "vía", "viaje", "vibrar", "vicio", "víctima", "vida", "vídeo", "vidrio", "viejo", "viernes", "vigor", "vil", "villa", "vinagre", "vino", "viñedo", "violín", "viral", "virgo", "virtud", "visor", "víspera", "vista", "vitamina", "viudo", "vivaz", "vivero", "vivir", "vivo", "volcán", "volumen", "volver", "voraz", "votar", "voto", "voz", "vuelo", "vulgar", "yacer", "yate", "yegua", "yema", "yerno", "yeso", "yodo", "yoga", "yogur", "zafiro", "zanja", "zapato", "zarza", "zona", "zorro", "zumo", "zurdo" }; } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/Account.java ================================================ package com.quincysx.crypto.bip44; import com.quincysx.crypto.bip32.Index; /** * @author QuincySx * @date 2018/3/5 下午4:27 */ public class Account { private final CoinType coinType; private final int account; private final String string; Account(final CoinType coinType, final int account) { if (Index.isHardened(account)) throw new IllegalArgumentException(); this.coinType = coinType; this.account = account; string = String.format("%s/%d'", coinType, account); } public int getValue() { return account; } public CoinType getParent() { return coinType; } @Override public String toString() { return string; } /** * Create a {@link Change} for this purpose, coin type and account. *

* Constant 0 is used for external chain. * External chain is used for addresses that are meant to be visible outside of the wallet (e.g. for receiving * payments). * * @return A {@link Change} = 0 instance for this purpose, coin type and account */ public Change external() { return new Change(this, 0); } /** * Create a {@link Change} for this purpose, coin type and account. *

* Constant 1 is used for internal chain (also known as change addresses). * Internal chain is used for addresses which are not meant to be visible outside of the wallet and is used for * return transaction change. * * @return A {@link Change} = 1 instance for this purpose, coin type and account */ public Change internal() { return new Change(this, 1); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/AddressIndex.java ================================================ package com.quincysx.crypto.bip44; import com.quincysx.crypto.bip32.Index; /** * @author QuincySx * @date 2018/3/5 下午4:28 */ public class AddressIndex { private final Change change; private final int addressIndex; private final boolean isHard; private final String string; AddressIndex(final Change change, final int addressIndex) { this(change, addressIndex, false); } AddressIndex(final Change change, final int addressIndex, final boolean head) { this.change = change; this.addressIndex = addressIndex; String s = "%s/%d"; if (head) { s += "'"; } string = String.format(s, change, addressIndex); this.isHard = head; } public int getValue() { if (isHard) { return Index.hard(addressIndex); } return addressIndex; } public Change getParent() { return change; } @Override public String toString() { return string; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/BIP44.java ================================================ package com.quincysx.crypto.bip44; import android.util.Log; import com.quincysx.crypto.CoinTypes; import com.quincysx.crypto.exception.CoinNotFindException; import com.quincysx.crypto.exception.NonSupportException; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * @author QuincySx * @date 2018/3/5 下午3:36 */ public final class BIP44 { private static final M M = new M(); BIP44() { } /** * Start creating a BIP44 path. * * @return A fluent factory for creating BIP44 paths */ public static M m() { return M; } public static AddressIndex parsePath(String path) throws NonSupportException, CoinNotFindException { // m/44'/60'/0'/0/0 String regEx = "m(/\\d+'?){3}/[0,1]/\\d+'?"; Pattern pattern = Pattern.compile(regEx); Matcher matcher = pattern.matcher(path); // 字符串是否与正则表达式相匹配 if (!matcher.matches()) { throw new NonSupportException("Path format is not correct"); } String[] split = path.split("/"); String purposeStr = split[1].substring(0, split[1].length() - 1); String coinTypeStr = split[2].substring(0, split[2].length() - 1); String accountStr = split[3].substring(0, split[3].length() - 1); String changeStr = split[4]; String addressStr; boolean addressHard = false; if (split[5].contains("'")) { addressStr = split[5].substring(0, split[5].length() - 1); addressHard = true; } else { addressStr = split[5]; } if ((Integer.parseInt(purposeStr)) != 44) { throw new NonSupportException("Only support the 44 protocol"); } Log.e("++++def", "ddddd " + Integer.parseInt(accountStr)); Account account = BIP44.m() .purpose44() .coinType(CoinTypes.parseCoinType(Integer.parseInt(coinTypeStr))) .account(Integer.parseInt(accountStr)); Change change; if (Integer.parseInt(changeStr) == 0) { change = account.external(); } else { change = account.internal(); } return change.address(Integer.parseInt(addressStr), addressHard); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/Change.java ================================================ package com.quincysx.crypto.bip44; /** * @author QuincySx * @date 2018/3/5 下午4:28 */ public class Change { private final Account account; private final int change; private final String string; Change(final Account account, final int change) { this.account = account; this.change = change; string = String.format("%s/%d", account, change); } public int getValue() { return change; } public Account getParent() { return account; } @Override public String toString() { return string; } /** * Create a {@link AddressIndex} for this purpose, coin type, account and change. * * @param addressIndex The index of the child * @return A coin type instance for this purpose, coin type, account and change. */ public AddressIndex address(final int addressIndex) { return address(addressIndex, false); } public AddressIndex address(final int addressIndex, final boolean hard) { return new AddressIndex(this, addressIndex, hard); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/CoinPairDerive.java ================================================ package com.quincysx.crypto.bip44; import android.util.Log; import com.quincysx.crypto.CoinTypes; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.bip32.ExtendedKey; import com.quincysx.crypto.bip32.Index; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.bitcoin.BitCoinECKeyPair; import com.quincysx.crypto.eos.EOSECKeyPair; import com.quincysx.crypto.ethereum.EthECKeyPair; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.SHA256; import org.spongycastle.crypto.digests.MD5Digest; import org.spongycastle.jcajce.provider.digest.MD5; import java.util.Map; import java.util.WeakHashMap; /** * @author QuincySx * @date 2018/3/5 下午3:48 */ public class CoinPairDerive { private ExtendedKey mExtendedKey; public CoinPairDerive(ExtendedKey extendedKey) { mExtendedKey = extendedKey; } public ExtendedKey deriveByExtendedKey(AddressIndex addressIndex) throws ValidationException { int address = addressIndex.getValue(); int change = addressIndex.getParent().getValue(); int account = addressIndex.getParent().getParent().getValue(); CoinTypes coinType = addressIndex.getParent().getParent().getParent().getValue(); int purpose = addressIndex.getParent().getParent().getParent().getParent().getValue(); ExtendedKey child = mExtendedKey .getChild(Index.hard(purpose)) .getChild(Index.hard(coinType.coinType())) .getChild(Index.hard(account)) .getChild(change) .getChild(address); return child; } public ECKeyPair derive(AddressIndex addressIndex) throws ValidationException { CoinTypes coinType = addressIndex.getParent().getParent().getParent().getValue(); ExtendedKey child = deriveByExtendedKey(addressIndex); ECKeyPair ecKeyPair = convertKeyPair(child, coinType); return ecKeyPair; } public ECKeyPair convertKeyPair(ExtendedKey child, CoinTypes coinType) throws ValidationException { switch (coinType) { case BitcoinTest: return BitCoinECKeyPair.parse(child.getMaster(), true);// convertBitcoinKeyPair(new BigInteger(1, child.getMaster().getPrivate()), true); case Ethereum: return EthECKeyPair.parse(child.getMaster());//convertEthKeyPair(new BigInteger(1, child.getMaster().getPrivate())); case EOS: return EOSECKeyPair.parse(child.getMaster()); case Bitcoin: default: return BitCoinECKeyPair.parse(child.getMaster(), false);//convertBitcoinKeyPair(new BigInteger(1, child.getMaster().getPrivate()), false); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/CoinType.java ================================================ package com.quincysx.crypto.bip44; import com.quincysx.crypto.CoinTypes; /** * @author QuincySx * @date 2018/3/5 下午4:26 */ public class CoinType { private final Purpose purpose; private final CoinTypes coinType; private final String string; CoinType(final Purpose purpose, final CoinTypes coinType) { this.purpose = purpose; this.coinType = coinType; string = String.format("%s/%d'", purpose, coinType.coinType()); } public CoinTypes getValue() { return coinType; } public Purpose getParent() { return purpose; } @Override public String toString() { return string; } /** * Create a {@link Account} for this purpose and coin type. * * @param account The account number * @return An {@link Account} instance for this purpose and coin type */ public Account account(final int account) { return new Account(this, account); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/M.java ================================================ package com.quincysx.crypto.bip44; /** * @author QuincySx * @date 2018/3/5 下午4:25 */ public final class M { private final Purpose PURPOSE_44 = new Purpose(this, 44); private final Purpose PURPOSE_49 = new Purpose(this, 49); M() { } /** * Create a {@link Purpose}. * For 44 and 49 this function is guaranteed to return the same instance. * * @param purpose The purpose number. * @return A purpose object. */ public Purpose purpose(final int purpose) { switch (purpose) { case 44: return PURPOSE_44; case 49: return PURPOSE_49; default: return new Purpose(this, purpose); } } public Purpose purpose44() { return PURPOSE_44; } public Purpose purpose49() { return PURPOSE_49; } @Override public String toString() { return "m"; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bip44/Purpose.java ================================================ package com.quincysx.crypto.bip44; import com.quincysx.crypto.CoinTypes; import com.quincysx.crypto.bip32.Index; /** * @author QuincySx * @date 2018/3/5 下午4:26 */ public final class Purpose { private final M m; private final int purpose; private final String toString; Purpose(final M m, final int purpose) { this.m = m; if (purpose == 0 || Index.isHardened(purpose)) throw new IllegalArgumentException(); this.purpose = purpose; toString = String.format("%s/%d'", m, purpose); } public int getValue() { return purpose; } @Override public String toString() { return toString; } /** * Create a {@link CoinType} for this purpose. * * @param coinType The coin type * @return A coin type instance for this purpose */ public CoinType coinType(final CoinTypes coinType) { return new CoinType(this, coinType); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bitcoin/BTCTransaction.java ================================================ /* The MIT License (MIT) Copyright (c) 2013 Valentin Konovalov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/ package com.quincysx.crypto.bitcoin; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.Transaction; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.utils.BTCUtils; import com.quincysx.crypto.utils.Base58; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.RIPEMD160; import com.quincysx.crypto.utils.SHA256; import java.io.ByteArrayOutputStream; import java.io.EOFException; import java.io.IOException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Arrays; import java.util.Stack; @SuppressWarnings("WeakerAccess") public final class BTCTransaction implements Transaction { public final int version; public final Input[] inputs; public final Output[] outputs; public final int lockTime; public BTCTransaction(byte[] rawBytes) throws BitcoinException { if (rawBytes == null) { throw new BitcoinException(BitcoinException.ERR_NO_INPUT, "empty input"); } BitcoinInputStream bais = null; try { bais = new BitcoinInputStream(rawBytes); version = bais.readInt32(); if (version != 1 && version != 2 && version != 3) { throw new BitcoinException(BitcoinException.ERR_UNSUPPORTED, "Unsupported TX " + "version", version); } int inputsCount = (int) bais.readVarInt(); inputs = new Input[inputsCount]; for (int i = 0; i < inputsCount; i++) { OutPoint outPoint = new OutPoint(BTCUtils.reverse(bais.readChars(32)), bais .readInt32()); byte[] script = bais.readChars((int) bais.readVarInt()); int sequence = bais.readInt32(); inputs[i] = new Input(outPoint, new Script(script), sequence); } int outputsCount = (int) bais.readVarInt(); outputs = new Output[outputsCount]; for (int i = 0; i < outputsCount; i++) { long value = bais.readInt64(); long scriptSize = bais.readVarInt(); if (scriptSize < 0 || scriptSize > 10_000_000) { throw new BitcoinException(BitcoinException.ERR_BAD_FORMAT, "Script size for " + "output " + i + " is strange (" + scriptSize + " bytes)."); } byte[] script = bais.readChars((int) scriptSize); outputs[i] = new Output(value, new Script(script)); } lockTime = bais.readInt32(); } catch (EOFException e) { throw new BitcoinException(BitcoinException.ERR_BAD_FORMAT, "TX incomplete"); } catch (IOException e) { throw new IllegalArgumentException("Unable to read TX"); } catch (Error e) { throw new IllegalArgumentException("Unable to read TX: " + e); } finally { if (bais != null) { try { bais.close(); } catch (IOException e) { e.printStackTrace(); } } } } public BTCTransaction(Input[] inputs, Output[] outputs, int lockTime) { this.version = 2; this.inputs = inputs; this.outputs = outputs; this.lockTime = lockTime; } @Override public byte[] getSignBytes() { return getBytes(); } public byte[] getBytes() { BitcoinOutputStream baos = new BitcoinOutputStream(); try { baos.writeInt32(version); baos.writeVarInt(inputs.length); for (Input input : inputs) { baos.write(BTCUtils.reverse(input.outPoint.hash)); baos.writeInt32(input.outPoint.index); int scriptLen = input.script == null ? 0 : input.script.bytes.length; baos.writeVarInt(scriptLen); if (scriptLen > 0) { baos.write(input.script.bytes); } baos.writeInt32(input.sequence); } baos.writeVarInt(outputs.length); for (Output output : outputs) { baos.writeInt64(output.value); int scriptLen = output.script == null ? 0 : output.script.bytes.length; baos.writeVarInt(scriptLen); if (scriptLen > 0) { baos.write(output.script.bytes); } } baos.writeInt32(lockTime); } catch (IOException e) { e.printStackTrace(); } finally { try { baos.close(); } catch (IOException e) { e.printStackTrace(); } } return baos.toByteArray(); } @Override public byte[] getData() { return new byte[0]; } @Override public String toString() { return "{" + "\n\"inputs\":\n" + printAsJsonArray(inputs) + ",\n\"outputs\":\n" + printAsJsonArray(outputs) + ",\n\"lockTime\":\"" + lockTime + "\"\n" + ",\n\"version\":\"" + version + "\"}\n"; } private String printAsJsonArray(Object[] a) { if (a == null) { return "null"; } if (a.length == 0) { return "[]"; } int iMax = a.length - 1; StringBuilder sb = new StringBuilder(); sb.append('['); for (int i = 0; ; i++) { sb.append(String.valueOf(a[i])); if (i == iMax) return sb.append(']').toString(); sb.append(",\n"); } } public static class Input { public final OutPoint outPoint; public final Script script; public final int sequence; public Input(OutPoint outPoint, Script script, int sequence) { this.outPoint = outPoint; this.script = script; this.sequence = sequence; } @Override public String toString() { return "{\n\"outPoint\":" + outPoint + ",\n\"script\":\"" + script + "\"," + "\n\"sequence\":\"" + Integer.toHexString(sequence) + "\"\n}\n"; } } public static class OutPoint { public final byte[] hash;//32-byte hash of the transaction from which we want to redeem // an output public final int index;//Four-byte field denoting the output index we want to redeem from // the transaction with the above hash (output number 2 = output index 1) public OutPoint(byte[] hash, int index) { this.hash = hash; this.index = index; } @Override public String toString() { return "{" + "\"hash\":\"" + HexUtils.toHex(hash) + "\", \"index\":\"" + index + "\"}"; } } public static class Output { public final long value; public final Script script; public Output(long value, Script script) { this.value = value; this.script = script; } @Override public String toString() { return "{\n\"value\":\"" + value * 1e-8 + "\",\"script\":\"" + script + "\"\n}"; } } public static final class Script { public static class ScriptInvalidException extends Exception { public ScriptInvalidException() { } public ScriptInvalidException(String s) { super(s); } } public static final byte OP_FALSE = 0; public static final byte OP_TRUE = 0x51; public static final byte OP_PUSHDATA1 = 0x4c; public static final byte OP_PUSHDATA2 = 0x4d; public static final byte OP_PUSHDATA4 = 0x4e; public static final byte OP_DUP = 0x76;//Duplicates the top stack item. public static final byte OP_DROP = 0x75; public static final byte OP_HASH160 = (byte) 0xA9;//The input is hashed twice: first with // SHA-256 and then with RIPEMD-160. public static final byte OP_VERIFY = 0x69;//Marks transaction as invalid if top stack // value is not true. True is removed, but false is not. public static final byte OP_EQUAL = (byte) 0x87;//Returns 1 if the inputs are exactly // equal, 0 otherwise. public static final byte OP_EQUALVERIFY = (byte) 0x88;//Same as OP_EQUAL, but runs // OP_VERIFY afterward. public static final byte OP_CHECKSIG = (byte) 0xAC;//The entire transaction's outputs, // inputs, and script (from the most recently-executed OP_CODESEPARATOR to the end) are // hashed. The signature used by OP_CHECKSIG must be a valid signature for this hash and // public key. If it is, 1 is returned, 0 otherwise. public static final byte OP_CHECKSIGVERIFY = (byte) 0xAD; public static final byte OP_NOP = 0x61; public static final byte OP_RETURN = 0x6a; public static final byte SIGHASH_ALL = 1; public final byte[] bytes; public Script(byte[] rawBytes) { bytes = rawBytes; } public Script(byte[] data1, byte[] data2) { ByteArrayOutputStream baos = new ByteArrayOutputStream(data1.length + data2.length + 2); try { writeBytes(data1, baos); writeBytes(data2, baos); baos.close(); } catch (IOException e) { throw new RuntimeException(e); } bytes = baos.toByteArray(); } private static void writeBytes(byte[] data, ByteArrayOutputStream baos) throws IOException { if (data.length < OP_PUSHDATA1) { baos.write(data.length); } else if (data.length < 0xff) { baos.write(OP_PUSHDATA1); baos.write(data.length); } else if (data.length < 0xffff) { // baos.write(OP_PUSHDATA2); // baos.write(data.length); baos.write(OP_PUSHDATA2); baos.write(data.length & 0xff); baos.write((data.length >> 8) & 0xff); } else { // baos.write(OP_PUSHDATA4); // baos.write(data.length); baos.write(OP_PUSHDATA4); baos.write(data.length & 0xff); baos.write((data.length >> 8) & 0xff); baos.write((data.length >> 16) & 0xff); baos.write((data.length >>> 24) & 0xff); } baos.write(data); } public void run(Stack stack) throws ScriptInvalidException { run(0, null, stack); } public void run(int inputIndex, BTCTransaction tx, Stack stack) throws ScriptInvalidException { for (int pos = 0; pos < bytes.length; pos++) { switch (bytes[pos]) { case OP_NOP: break; case OP_DROP: if (stack.isEmpty()) { throw new IllegalArgumentException("stack empty on OP_DROP"); } stack.pop(); break; case OP_DUP: if (stack.isEmpty()) { throw new IllegalArgumentException("stack empty on OP_DUP"); } stack.push(stack.peek()); break; case OP_HASH160: if (stack.isEmpty()) { throw new IllegalArgumentException("stack empty on OP_HASH160"); } stack.push(RIPEMD160.hash160(stack.pop())); break; case OP_EQUAL: case OP_EQUALVERIFY: if (stack.size() < 2) { throw new IllegalArgumentException("not enough elements to perform " + "OP_EQUAL"); } stack.push(new byte[]{(byte) (Arrays.equals(stack.pop(), stack.pop()) ? 1 : 0)}); if (bytes[pos] == OP_EQUALVERIFY) { if (verifyFails(stack)) { throw new ScriptInvalidException("wrong address"); } } break; case OP_VERIFY: if (verifyFails(stack)) { throw new ScriptInvalidException(); } break; case OP_CHECKSIG: case OP_CHECKSIGVERIFY: byte[] publicKey = stack.pop(); byte[] signatureAndHashType = stack.pop(); if (signatureAndHashType[signatureAndHashType.length - 1] != SIGHASH_ALL) { throw new IllegalArgumentException("I cannot check this sig type: " + signatureAndHashType[signatureAndHashType.length - 1]); } byte[] signature = new byte[signatureAndHashType.length - 1]; System.arraycopy(signatureAndHashType, 0, signature, 0, signature.length); byte[] hash = hashTransaction(inputIndex, bytes, tx); boolean valid = BTCUtils.verify(publicKey, signature, hash); if (bytes[pos] == OP_CHECKSIG) { stack.push(new byte[]{(byte) (valid ? 1 : 0)}); } else { if (verifyFails(stack)) { throw new ScriptInvalidException("Bad signature"); } if (!stack.empty()) { throw new ScriptInvalidException("Bad signature - superfluous " + "scriptSig operations"); } } break; case OP_FALSE: stack.push(new byte[]{0}); break; case OP_TRUE: stack.push(new byte[]{1}); break; default: int op = bytes[pos] & 0xff; int len; if (op < OP_PUSHDATA1) { len = op; byte[] data = new byte[len]; System.arraycopy(bytes, pos + 1, data, 0, len); stack.push(data); pos += data.length; } else if (op == OP_PUSHDATA1) { len = bytes[pos + 1] & 0xff; byte[] data = new byte[len]; System.arraycopy(bytes, pos + 1, data, 0, len); stack.push(data); pos += 1 + data.length; } else { throw new IllegalArgumentException("I cannot read this data: " + Integer.toHexString(bytes[pos])); } break; } } } public static byte[] hashTransaction(int inputIndex, byte[] subscript, BTCTransaction tx) { Input[] unsignedInputs = new Input[tx.inputs.length]; for (int i = 0; i < tx.inputs.length; i++) { Input txInput = tx.inputs[i]; if (i == inputIndex) { unsignedInputs[i] = new Input(txInput.outPoint, new Script(subscript), txInput.sequence); } else { unsignedInputs[i] = new Input(txInput.outPoint, new Script(new byte[0]), txInput.sequence); } } BTCTransaction unsignedTransaction = new BTCTransaction(unsignedInputs, tx.outputs, tx.lockTime); return hashTransactionForSigning(unsignedTransaction); } public static byte[] hashTransactionForSigning(BTCTransaction unsignedTransaction) { byte[] txUnsignedBytes = unsignedTransaction.getSignBytes(); BitcoinOutputStream baos = new BitcoinOutputStream(); try { baos.write(txUnsignedBytes); baos.writeInt32(BTCTransaction.Script.SIGHASH_ALL); baos.close(); } catch (Exception e) { throw new RuntimeException(e); } return SHA256.doubleSha256(baos.toByteArray()); } public static boolean verifyFails(Stack stack) { byte[] input; boolean valid; input = stack.pop(); if (input.length == 0 || (input.length == 1 && input[0] == OP_FALSE)) { //false stack.push(new byte[]{OP_FALSE}); valid = false; } else { //true valid = true; } return !valid; } @Override public String toString() { return convertBytesToReadableString(bytes); } //converts something like "OP_DUP OP_HASH160 ba507bae8f1643d2556000ca26b9301b9069dc6b // OP_EQUALVERIFY OP_CHECKSIG" into bytes public static byte[] convertReadableStringToBytes(String readableString) { String[] tokens = readableString.trim().split("\\s+"); ByteArrayOutputStream os = new ByteArrayOutputStream(); for (String token : tokens) { switch (token) { case "OP_NOP": os.write(OP_NOP); break; case "OP_DROP": os.write(OP_DROP); break; case "OP_DUP": os.write(OP_DUP); break; case "OP_HASH160": os.write(OP_HASH160); break; case "OP_EQUAL": os.write(OP_EQUAL); break; case "OP_EQUALVERIFY": os.write(OP_EQUALVERIFY); break; case "OP_VERIFY": os.write(OP_VERIFY); break; case "OP_CHECKSIG": os.write(OP_CHECKSIG); break; case "OP_CHECKSIGVERIFY": os.write(OP_CHECKSIGVERIFY); break; case "OP_FALSE": os.write(OP_FALSE); break; case "OP_TRUE": os.write(OP_TRUE); break; default: if (token.startsWith("OP_")) { throw new IllegalArgumentException("I don't know this operation: " + token); } byte[] data = HexUtils.fromHex(token); if (data == null) { throw new IllegalArgumentException("I don't know what's this: " + token); } if (data.length < OP_PUSHDATA1) { os.write(data.length); try { os.write(data); } catch (IOException e) { throw new RuntimeException("ByteArrayOutputStream behaves weird: " + "" + e); } } else if (data.length <= 255) { os.write(OP_PUSHDATA1); os.write(data.length); try { os.write(data); } catch (IOException e) { throw new RuntimeException("ByteArrayOutputStream behaves weird: " + "" + e); } } else { throw new IllegalArgumentException("OP_PUSHDATA2 & OP_PUSHDATA4 are " + "not supported"); } break; } } try { os.close(); } catch (IOException e) { e.printStackTrace(); } return os.toByteArray(); } public static String convertBytesToReadableString(byte[] bytes) { StringBuilder sb = new StringBuilder(); for (int pos = 0; pos < bytes.length; pos++) { if (sb.length() > 0) { sb.append(' '); } switch (bytes[pos]) { case OP_NOP: sb.append("OP_NOP"); break; case OP_DROP: sb.append("OP_DROP"); break; case OP_DUP: sb.append("OP_DUP"); break; case OP_HASH160: sb.append("OP_HASH160"); break; case OP_EQUAL: sb.append("OP_EQUAL"); break; case OP_EQUALVERIFY: sb.append("OP_EQUALVERIFY"); break; case OP_VERIFY: sb.append("OP_VERIFY"); break; case OP_CHECKSIG: sb.append("OP_CHECKSIG"); break; case OP_CHECKSIGVERIFY: sb.append("OP_CHECKSIGVERIFY"); break; case OP_FALSE: sb.append("OP_FALSE"); break; case OP_TRUE: sb.append("OP_TRUE"); break; default: int op = bytes[pos] & 0xff; int len; if (op < OP_PUSHDATA1) { len = op; byte[] data = new byte[len]; System.arraycopy(bytes, pos + 1, data, 0, len); sb.append(HexUtils.toHex(data)); pos += data.length; } else if (op == OP_PUSHDATA1) { len = bytes[pos + 1] & 0xff; byte[] data = new byte[len]; System.arraycopy(bytes, pos + 1, data, 0, len);//FIXME I suspect // there is off by one error... sb.append(HexUtils.toHex(data)); pos += 1 + data.length; } else { throw new IllegalArgumentException("I cannot read this data: " + Integer.toHexString(bytes[pos]) + " at " + pos); } break; } } return sb.toString(); } @Override public boolean equals(Object o) { return this == o || !(o == null || getClass() != o.getClass()) && Arrays.equals (bytes, ((Script) o).bytes); } @Override public int hashCode() { return Arrays.hashCode(bytes); } public static Script buildOutput(String address) throws BitcoinException { //noinspection TryWithIdenticalCatches try { byte[] addressWithCheckSumAndNetworkCode = Base58.decode(address); if (addressWithCheckSumAndNetworkCode[0] != 0 && addressWithCheckSumAndNetworkCode[0] != 111 && addressWithCheckSumAndNetworkCode[0] != 5) { throw new BitcoinException(BitcoinException.ERR_UNSUPPORTED, "Unknown address" + " type", address); } byte[] bareAddress = new byte[20]; System.arraycopy(addressWithCheckSumAndNetworkCode, 1, bareAddress, 0, bareAddress.length); MessageDigest digestSha = MessageDigest.getInstance("SHA-256"); digestSha.update(addressWithCheckSumAndNetworkCode, 0, addressWithCheckSumAndNetworkCode.length - 4); byte[] calculatedDigest = digestSha.digest(digestSha.digest()); for (int i = 0; i < 4; i++) { if (calculatedDigest[i] != addressWithCheckSumAndNetworkCode[addressWithCheckSumAndNetworkCode .length - 4 + i]) { throw new BitcoinException(BitcoinException.ERR_BAD_FORMAT, "Bad " + "address", address); } } if (addressWithCheckSumAndNetworkCode[0] == 5) { //P2SH 的锁定脚本 ByteArrayOutputStream buf = new ByteArrayOutputStream(); buf.write(OP_HASH160); writeBytes(bareAddress, buf); buf.write(OP_EQUAL); return new Script(buf.toByteArray()); } else { //P2PKH 的锁定脚本 ByteArrayOutputStream buf = new ByteArrayOutputStream(25); buf.write(OP_DUP); buf.write(OP_HASH160); writeBytes(bareAddress, buf); buf.write(OP_EQUALVERIFY); buf.write(OP_CHECKSIG); return new Script(buf.toByteArray()); } } catch (NoSuchAlgorithmException e) { throw new RuntimeException(e); } catch (IOException e) { throw new RuntimeException(e); } } } @Override public byte[] sign(ECKeyPair key) throws ValidationException { BTCTransaction sign = key.sign(this.getSignBytes()); int length = sign.inputs.length; for (int i = 0; i < length; i++) { this.inputs[i] = sign.inputs[i]; } // return sign.getSignBytes(); return getSignBytes(); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bitcoin/BitCoinECKeyPair.java ================================================ package com.quincysx.crypto.bitcoin; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.Key; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.utils.Base58; import com.quincysx.crypto.utils.Base58Check; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.RIPEMD160; import com.quincysx.crypto.utils.SHA256; import org.spongycastle.asn1.ASN1Integer; import org.spongycastle.asn1.DERInteger; import org.spongycastle.asn1.DERSequenceGenerator; import org.spongycastle.crypto.digests.SHA256Digest; import org.spongycastle.crypto.params.ECPrivateKeyParameters; import org.spongycastle.crypto.params.ParametersWithRandom; import org.spongycastle.crypto.signers.ECDSASigner; import org.spongycastle.crypto.signers.HMacDSAKCalculator; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.math.BigInteger; import java.util.Arrays; /** * @author QuincySx * @date 2018/3/8 上午10:56 */ public class BitCoinECKeyPair extends ECKeyPair { private static final int TEST_NET_ADDRESS_SUFFIX = 0x6f; private static final int MAIN_NET_ADDRESS_SUFFIX = 0x00; public static final int MAIN_NET_PRIVATE_KEY_PREFIX = 0x80; public static final int TEST_NET_PRIVATE_KEY_PREFIX = 0xef; private static final int MAIN_NET_PRIVATE_KEY_SUFFIX = 0x01; private static final int RAW_PRIVATE_KEY_COMPRESSED_LENGTH = 38; private static final int RAW_PRIVATE_KEY_NO_COMPRESSED_LENGTH = 37; private final boolean testNet; public static BitCoinECKeyPair parse(Key keyPair, boolean testNet) { return new BitCoinECKeyPair(keyPair, testNet); } public static BitCoinECKeyPair parseWIF(String wif) throws ValidationException { byte[] decode = Base58.decode(wif); //判断私钥格式 byte[] check = new byte[4]; System.arraycopy(decode, decode.length - 4, check, 0, check.length); byte[] privateCheck = SHA256.doubleSha256(decode, 0, decode.length - 4); for (int i = 0; i < 4; i++) { if (check[i] != privateCheck[i]) { throw new ValidationException("WIF Private Key Incorrect format"); } } boolean isCompressed = false; if (decode.length == RAW_PRIVATE_KEY_COMPRESSED_LENGTH) { isCompressed = true; } boolean isTestNet = false; if ((decode[0] & 0xFF) == TEST_NET_PRIVATE_KEY_PREFIX) { isTestNet = true; } byte[] bytes = new byte[32]; System.arraycopy(decode, 1, bytes, 0, bytes.length); return new BitCoinECKeyPair(bytes, isTestNet, isCompressed); } public BitCoinECKeyPair(byte[] p, boolean testNet, boolean compressed) throws ValidationException { super(p, compressed); this.testNet = testNet; } public BitCoinECKeyPair(BigInteger priv, boolean testNet, boolean compressed) { super(priv, compressed); this.testNet = testNet; } public BitCoinECKeyPair(Key keyPair, boolean testNet) { super(keyPair); this.testNet = testNet; } protected BitCoinECKeyPair(BigInteger priv, boolean compressed) throws ValidationException { super(priv, compressed); this.testNet = false; } public boolean isTestNet() { return testNet; } @Override public String getPrivateKey() { byte[] bytes = getRawPrivateKey(); byte[] rawPrivateKey = new byte[isCompressed() ? RAW_PRIVATE_KEY_COMPRESSED_LENGTH : RAW_PRIVATE_KEY_NO_COMPRESSED_LENGTH]; System.arraycopy(bytes, 0, rawPrivateKey, 1, bytes.length); rawPrivateKey[0] = (byte) (isTestNet() ? TEST_NET_PRIVATE_KEY_PREFIX : MAIN_NET_PRIVATE_KEY_PREFIX); if (isCompressed()) { rawPrivateKey[rawPrivateKey.length - 5] = MAIN_NET_PRIVATE_KEY_SUFFIX; } byte[] check = SHA256.doubleSha256(rawPrivateKey, 0, rawPrivateKey.length - 4); System.arraycopy(check, 0, rawPrivateKey, rawPrivateKey.length - 4, 4); return Base58.encode(rawPrivateKey); } @Override public String getPublicKey() { return HexUtils.toHex(getRawPublicKey()); } @Override public String getAddress() { return Base58.encode(getRawAddress()); } @Override public byte[] getRawPublicKey() { return getRawPublicKey(isCompressed()); } @Override public byte[] getRawAddress() { byte[] hashedPublicKey; //进行 Sha256 Ripemd160 运算 if (isCompressed()) { hashedPublicKey = RIPEMD160.hash160(pubComp); } else { hashedPublicKey = RIPEMD160.hash160(pub); } byte[] addressBytes = new byte[1 + hashedPublicKey.length + 4]; //拼接测试网络或正式网络前缀 addressBytes[0] = (byte) (testNet ? TEST_NET_ADDRESS_SUFFIX : MAIN_NET_ADDRESS_SUFFIX); System.arraycopy(hashedPublicKey, 0, addressBytes, 1, hashedPublicKey.length); //进行双 Sha256 运算 byte[] check = SHA256.doubleSha256(addressBytes, 0, addressBytes.length - 4); //将双 Sha256 运算的结果前 4位 拼接到尾部 System.arraycopy(check, 0, addressBytes, hashedPublicKey.length + 1, 4); Arrays.fill(hashedPublicKey, (byte) 0); Arrays.fill(check, (byte) 0); return addressBytes; } @Override public BTCTransaction sign(byte[] messageHash) throws ValidationException { try { BTCTransaction btcTransaction = new BTCTransaction(messageHash); return signTransaction(btcTransaction, priv, getRawPublicKey(), getAddress()); } catch (BitcoinException e) { e.printStackTrace(); throw new ValidationException(e); } } public byte[] signBTC(byte[] hash) { ECDSASigner signer = new ECDSASigner(); signer.init(true, new ECPrivateKeyParameters(priv, domain)); BigInteger[] signature = signer.generateSignature(hash); ByteArrayOutputStream s = new ByteArrayOutputStream(); try { DERSequenceGenerator seq = new DERSequenceGenerator(s); seq.addObject(new DERInteger(signature[0])); seq.addObject(new DERInteger(signature[1])); seq.close(); return s.toByteArray(); } catch (IOException e) { } return null; } public boolean verifyBTC(byte[] hash, byte[] signature) { return verify(hash, signature, pubComp); } private static void checkChecksum(byte[] store) throws ValidationException { byte[] checksum = new byte[4]; System.arraycopy(store, store.length - 4, checksum, 0, 4); byte[] ekey = new byte[store.length - 4]; System.arraycopy(store, 0, ekey, 0, store.length - 4); byte[] hash = SHA256.doubleSha256(ekey); for (int i = 0; i < 4; ++i) { if (hash[i] != checksum[i]) { throw new ValidationException("checksum mismatch"); } } } public static BTCTransaction signTransaction(BTCTransaction transaction, BigInteger privateKeyBigInteger, byte[] publicKey, String address) { BTCTransaction.Input[] signedInput = new BTCTransaction.Input[transaction.inputs.length]; for (int i = 0; i < transaction.inputs.length; i++) { signedInput[i] = sign(transaction, i, privateKeyBigInteger, publicKey, address, BTCTransaction.Script.SIGHASH_ALL); } return new BTCTransaction(signedInput, transaction.outputs, transaction.lockTime); } /** * 对单个Input进行签名 * * @param transaction 交易 * @param index Input索引 * @reture 签名完毕的Input */ public static BTCTransaction.Input sign(BTCTransaction transaction, int index, BigInteger privateKeyBigInteger, byte[] publicKey, String address, byte ScriptType) { String publicScript = mkPubKeyScript(address); //清空无关Input的Script,对相关Script进行签名 signatureForm(transaction, index, publicScript); //双 Sha256 and 签名 byte[] signature = sign(privateKeyBigInteger, BTCTransaction.Script .hashTransactionForSigning(transaction)); //拼版本 byte[] signatureAndHashType = new byte[signature.length + 1]; System.arraycopy(signature, 0, signatureAndHashType, 0, signature.length); signatureAndHashType[signatureAndHashType.length - 1] = ScriptType; //拼出新的input return new BTCTransaction.Input(transaction.inputs[index].outPoint, new BTCTransaction .Script(signatureAndHashType, publicKey), transaction.inputs[index].sequence); } /** * 设置Input的地址签名 * * @param transaction 交易 * @param index 索引 * @param publicScript 地址签名 * @return 新的交易 */ private static BTCTransaction signatureForm(BTCTransaction transaction, int index, String publicScript) { //存放清空地址签名的Input for (int i = 0; i < transaction.inputs.length; i++) { BTCTransaction.Script script = null; if (i == index) { //设置地址签名 script = new BTCTransaction.Script(HexUtils.fromHex(publicScript)); } transaction.inputs[i] = new BTCTransaction.Input(transaction.inputs[i].outPoint, script, transaction.inputs[i].sequence); } return transaction; } /** * 签署地址签名 * * @param address 地址 * @return 签名 */ private static String mkPubKeyScript(String address) { //设置加密格式 StringBuilder stringBuilder = new StringBuilder(); stringBuilder.append("76a914"); //设置签名 byte[] bytes = Base58Check.base58ToBytes(address); byte[] checkByte = new byte[bytes.length - 1]; System.arraycopy(bytes, 1, checkByte, 0, checkByte.length); stringBuilder.append(HexUtils.toHex(checkByte)); Arrays.fill(bytes, (byte) 0); Arrays.fill(checkByte, (byte) 0); //设置签名后缀格式 stringBuilder.append("88ac"); return stringBuilder.toString(); } public static byte[] sign(BigInteger privateKey, byte[] input) { synchronized (domain) { ECDSASigner signer = new ECDSASigner(new HMacDSAKCalculator(new SHA256Digest())); ECPrivateKeyParameters privateKeyParam = new ECPrivateKeyParameters(privateKey, domain); signer.init(true, new ParametersWithRandom(privateKeyParam, secureRandom)); BigInteger[] sign = signer.generateSignature(input); BigInteger r = sign[0]; BigInteger s = sign[1]; BigInteger largestAllowedS = new BigInteger ("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0", 16); //SECP256K1_N_DIV_2 if (s.compareTo(largestAllowedS) > 0) { //https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#low-s-values-in // -signatures s = LARGEST_PRIVATE_KEY.subtract(s); } try { ByteArrayOutputStream baos = new ByteArrayOutputStream(72); DERSequenceGenerator derGen = new DERSequenceGenerator(baos); derGen.addObject(new ASN1Integer(r)); derGen.addObject(new ASN1Integer(s)); derGen.close(); return baos.toByteArray(); } catch (IOException e) { throw new RuntimeException(e); } } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bitcoin/BitcoinException.java ================================================ /* The MIT License (MIT) Copyright (c) 2013-2014 Valentin Konovalov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/ package com.quincysx.crypto.bitcoin; @SuppressWarnings("WeakerAccess") public final class BitcoinException extends Exception { public static final int ERR_NO_SPENDABLE_OUTPUTS_FOR_THE_ADDRESS = 0; public static final int ERR_INSUFFICIENT_FUNDS = 1; public static final int ERR_WRONG_TYPE = 2; public static final int ERR_BAD_FORMAT = 3; public static final int ERR_INCORRECT_PASSWORD = 4; public static final int ERR_MEANINGLESS_OPERATION = 5; public static final int ERR_NO_INPUT = 6; public static final int ERR_FEE_IS_TOO_BIG = 7; public static final int ERR_FEE_IS_LESS_THEN_ZERO = 8; public static final int ERR_CHANGE_IS_LESS_THEN_ZERO = 9; public static final int ERR_AMOUNT_TO_SEND_IS_LESS_THEN_ZERO = 10; public static final int ERR_UNSUPPORTED = 11; public final int errorCode; @SuppressWarnings({"WeakerAccess", "unused"}) public final Object extraInformation; public BitcoinException(int errorCode, String detailMessage, Object extraInformation) { super(detailMessage); this.errorCode = errorCode; this.extraInformation = extraInformation; } public BitcoinException(int errorCode, String detailMessage) { this(errorCode, detailMessage, null); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bitcoin/BitcoinInputStream.java ================================================ /* The MIT License (MIT) Copyright (c) 2013 Valentin Konovalov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/ package com.quincysx.crypto.bitcoin; import java.io.ByteArrayInputStream; import java.io.EOFException; import java.io.IOException; @SuppressWarnings("WeakerAccess") public class BitcoinInputStream extends ByteArrayInputStream { public BitcoinInputStream(byte[] buf) { super(buf); } @SuppressWarnings("unused") public BitcoinInputStream(byte[] buf, int offset, int length) { super(buf, offset, length); } public int readInt16() throws EOFException { return (readByte() & 0xff) | ((readByte() & 0xff) << 8); } public int readInt32() throws EOFException { return (readByte() & 0xff) | ((readByte() & 0xff) << 8) | ((readByte() & 0xff) << 16) | ((readByte() & 0xff) << 24); } public long readInt64() throws EOFException { return (readInt32() & 0xFFFFFFFFL )| ((readInt32() & 0xFFFFFFFFL) << 32); } public int readByte() throws EOFException { int readedByte = super.read(); if (readedByte == -1) { throw new EOFException(); } return readedByte; } public long readVarInt() throws EOFException { int readedByte = readByte(); if (readedByte < 0xfd) { return readedByte; } else if (readedByte == 0xfd) { return readInt16(); } else if (readedByte == 0xfe) { return readInt32(); } else { return readInt64(); } } public byte[] readChars(final int count) throws IOException { byte[] buf = new byte[count]; int off = 0; while (off != count) { int bytesReadCurr = read(buf, off, count - off); if (bytesReadCurr == -1) { throw new EOFException(); } else { off += bytesReadCurr; } } return buf; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/bitcoin/BitcoinOutputStream.java ================================================ /* The MIT License (MIT) Copyright (c) 2013 Valentin Konovalov Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.*/ package com.quincysx.crypto.bitcoin; import java.io.ByteArrayOutputStream; @SuppressWarnings("WeakerAccess") public final class BitcoinOutputStream extends ByteArrayOutputStream { public void writeInt16(int value) { write(value & 0xff); write((value >> 8) & 0xff); } public void writeInt32(int value) { write(value & 0xff); write((value >> 8) & 0xff); write((value >> 16) & 0xff); write((value >>> 24) & 0xff); } public void writeInt64(long value) { writeInt32((int) (value & 0xFFFFFFFFL)); writeInt32((int) ((value >>> 32) & 0xFFFFFFFFL)); } public void writeVarInt(long value) { if (value < 0xfd) { write((int) (value & 0xff)); } else if (value < 0xffff) { write(0xfd); writeInt16((int) value); } else if (value < 0xffffffffL) { write(0xfe); writeInt32((int) value); } else { write(0xff); writeInt64(value); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/eip55/EthCheckAddress.java ================================================ package com.quincysx.crypto.eip55; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.KECCAK256; /** * @author QuincySx * @date 2018/6/20 下午5:39 */ public class EthCheckAddress { /** * 生成 Checksum 的地址 * * @param address 普通地址 * @return Checksum 地址 */ public static String toChecksumAddress(String address) { String lowercaseAddress = cleanHexPrefix(address).toLowerCase(); String addressHash = (HexUtils.toHex(KECCAK256.keccak256(lowercaseAddress.getBytes()))); StringBuilder result = new StringBuilder(lowercaseAddress.length() + 2); if (containsHexPrefix(address)) { result.append("0x"); } for (int i = 0; i < lowercaseAddress.length(); i++) { if (Integer.parseInt(String.valueOf(addressHash.charAt(i)), 16) >= 8) { result.append(String.valueOf(lowercaseAddress.charAt(i)).toUpperCase()); } else { result.append(lowercaseAddress.charAt(i)); } } return result.toString(); } /** * 检查 ETH 地址是否合法 * * @param address ETH 地址 * @return true：合法 false：不合法 */ public static boolean checksumAddress(String address) { if (!containsHexPrefix(address)) { //没有前缀 0x return false; } else if (checkUppercase(cleanHexPrefix(address))) { String checksumAddress = toChecksumAddress(address); if (checksumAddress.equals(address)) { return true; } return false; } else { return true; } } /** * 检查字符串中是否有大写英文字母 * * @param address ETH 地址 * @return true：大写 false：小写 */ private static boolean checkUppercase(String address) { for (int i = 0; i < address.length(); i++) { char c = address.charAt(i); if (Character.isUpperCase(c)) { return true; } } return false; } /** * 如果字符串 0x 开头则去掉 * * @param input 要处理的字符串 * @return 处理完成的字符串 */ public static String cleanHexPrefix(String input) { if (containsHexPrefix(input)) { return input.substring(2); } else { return input; } } /** * 检查字符串是否是 0x 开头 * * @param input 要检测的字符串 * @return true：0x 开头 false：不是 0x 开头 */ public static boolean containsHexPrefix(String input) { return !isEmpty(input) && input.length() > 1 && input.charAt(0) == '0' && input.charAt(1) == 'x'; } private static boolean isEmpty(String s) { return s == null || s.length() == 0; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/eos/EOSECKeyPair.java ================================================ package com.quincysx.crypto.eos; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.Key; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.utils.Base58; import com.quincysx.crypto.utils.KECCAK256; import com.quincysx.crypto.utils.RIPEMD160; import com.quincysx.crypto.utils.SHA256; import java.lang.reflect.Array; import java.math.BigInteger; import java.util.Arrays; /** * @author QuincySx * @date 2018/6/13 上午11:28 */ public class EOSECKeyPair extends ECKeyPair { public static final String address_prefix = "EOS"; public static final int PRIVATE_KEY_PREFIX = 0x80; public static EOSECKeyPair parse(Key keyPair) { return new EOSECKeyPair(keyPair); } public static EOSECKeyPair parse(String privateKey) throws ValidationException { byte[] decode = Base58.decode(privateKey); byte[] checksum = SHA256.doubleSha256(decode, 0, decode.length - 4); for (int i = 0; i < 4; i++) { if (decode[decode.length - 4 + i] != checksum[i]) { throw new ValidationException("私钥验证失败"); } } byte[] key = new byte[decode.length - 5]; System.arraycopy(decode, 1, key, 0, key.length); BigInteger integer = new BigInteger(1, key); Arrays.fill(key, (byte) 0); Arrays.fill(decode, (byte) 0); Arrays.fill(checksum, (byte) 0); return new EOSECKeyPair(integer); } public EOSECKeyPair(byte[] p) throws ValidationException { super(p, true); } public EOSECKeyPair(BigInteger priv) { super(priv, true); } public EOSECKeyPair(Key keyPair) { super(keyPair); } @Override public byte[] getRawPrivateKey() { return super.getRawPrivateKey(); } @Override public String getPrivateKey() { byte[] rawPrivateKey = getRawPrivateKey(); byte[] privateKey = new byte[rawPrivateKey.length + 5]; privateKey[0] = (byte) PRIVATE_KEY_PREFIX; System.arraycopy(rawPrivateKey, 0, privateKey, 1, rawPrivateKey.length); byte[] checksum = SHA256.doubleSha256(privateKey, 0, privateKey.length - 4); System.arraycopy(checksum, 0, privateKey, rawPrivateKey.length + 1, 4); Arrays.fill(checksum, (byte) 0); Arrays.fill(rawPrivateKey, (byte) 0); return Base58.encode(privateKey); } @Override public byte[] getRawPublicKey() { byte[] publicKey = new byte[pubComp.length]; System.arraycopy(pubComp, 0, publicKey, 0, publicKey.length); return publicKey; } @Override public String getPublicKey() { byte[] rawPublicKey = getRawPublicKey(); byte[] publicKey = new byte[rawPublicKey.length + 4]; System.arraycopy(rawPublicKey, 0, publicKey, 0, rawPublicKey.length); byte[] bytes = RIPEMD160.ripemd160(rawPublicKey); System.arraycopy(bytes, 0, publicKey, rawPublicKey.length, 4); StringBuffer bf = new StringBuffer(address_prefix); bf.append(Base58.encode(publicKey)); Arrays.fill(rawPublicKey, (byte) 0); Arrays.fill(publicKey, (byte) 0); Arrays.fill(bytes, (byte) 0); return bf.toString(); } @Override public byte[] getRawAddress() { byte[] byteAddress = KECCAK256.keccak256(getRawPublicKey()); byte[] address = new byte[20]; System.arraycopy(byteAddress, 12, address, 0, address.length); return address; } @Override public String getAddress() { return getPublicKey(); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/Bloom.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum; import com.quincysx.crypto.ethereum.utils.ByteUtil; import org.spongycastle.util.encoders.Hex; import java.util.Arrays; /** * See http://www.herongyang.com/Java/Bit-String-Set-Bit-to-Byte-Array.html. * * @author Roman Mandeleil * @since 20.11.2014 */ public class Bloom { final static int _8STEPS = 8; final static int _3LOW_BITS = 7; final static int ENSURE_BYTE = 255; byte[] data = new byte[256]; public Bloom() { } public Bloom(byte[] data) { this.data = data; } public static Bloom create(byte[] toBloom) { int mov1 = (((toBloom[0] & ENSURE_BYTE) & (_3LOW_BITS)) << _8STEPS) + ((toBloom[1]) & ENSURE_BYTE); int mov2 = (((toBloom[2] & ENSURE_BYTE) & (_3LOW_BITS)) << _8STEPS) + ((toBloom[3]) & ENSURE_BYTE); int mov3 = (((toBloom[4] & ENSURE_BYTE) & (_3LOW_BITS)) << _8STEPS) + ((toBloom[5]) & ENSURE_BYTE); byte[] data = new byte[256]; Bloom bloom = new Bloom(data); ByteUtil.setBit(data, mov1, 1); ByteUtil.setBit(data, mov2, 1); ByteUtil.setBit(data, mov3, 1); return bloom; } public void or(Bloom bloom) { for (int i = 0; i < data.length; ++i) { data[i] |= bloom.data[i]; } } public boolean matches(Bloom topicBloom) { Bloom copy = copy(); copy.or(topicBloom); return this.equals(copy); } public byte[] getData() { return data; } public Bloom copy() { return new Bloom(Arrays.copyOf(getData(), getData().length)); } @Override public String toString() { return Hex.toHexString(data); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Bloom bloom = (Bloom) o; return Arrays.equals(data, bloom.data); } @Override public int hashCode() { return data != null ? Arrays.hashCode(data) : 0; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/ByteArrayWrapper.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum; import com.quincysx.crypto.ethereum.utils.FastByteComparisons; import org.spongycastle.util.encoders.Hex; import java.io.Serializable; import java.util.Arrays; /** * @author Roman Mandeleil * @since 11.06.2014 */ public class ByteArrayWrapper implements Comparable, Serializable { private final byte[] data; private int hashCode = 0; public ByteArrayWrapper(byte[] data) { if (data == null) throw new NullPointerException("Data must not be null"); this.data = data; this.hashCode = Arrays.hashCode(data); } public boolean equals(Object other) { if (!(other instanceof ByteArrayWrapper)) return false; byte[] otherData = ((ByteArrayWrapper) other).getData(); return FastByteComparisons.compareTo( data, 0, data.length, otherData, 0, otherData.length) == 0; } @Override public int hashCode() { return hashCode; } @Override public int compareTo(ByteArrayWrapper o) { return FastByteComparisons.compareTo( data, 0, data.length, o.getData(), 0, o.getData().length); } public byte[] getData() { return data; } @Override public String toString() { return Hex.toHexString(data); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/CallTransaction.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum; import static com.quincysx.crypto.ethereum.utils.ByteUtil.longToBytesNoLeadZeroes; import static java.lang.String.format; import static com.quincysx.crypto.ethereum.solidity.SolidityType.IntType; import com.fasterxml.jackson.annotation.JsonGetter; import com.fasterxml.jackson.annotation.JsonInclude; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.ObjectMapper; import com.quincysx.crypto.ethereum.solidity.SolidityType; import com.quincysx.crypto.ethereum.utils.ByteUtil; import com.quincysx.crypto.ethereum.utils.FastByteComparisons; import com.quincysx.crypto.ethereum.vm.LogInfo; import com.quincysx.crypto.utils.KECCAK256; import java.io.IOException; import java.math.BigInteger; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.function.Function; import org.spongycastle.pqc.math.linearalgebra.ByteUtils; import org.spongycastle.util.BigIntegers; import org.spongycastle.util.encoders.Hex; /** * Creates a contract function call transaction. * Serializes arguments according to the function ABI . *

* Created by Anton Nashatyrev on 25.08.2015. */ public class CallTransaction { private final static ObjectMapper DEFAULT_MAPPER = new ObjectMapper() .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES) .enable(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL); public static EthTransaction createRawTransaction(BigInteger nonce, BigInteger gasPrice, BigInteger gasLimit, String toAddress, BigInteger value, byte[] data) { EthTransaction tx = new EthTransaction(BigIntegers.asUnsignedByteArray(nonce), BigIntegers.asUnsignedByteArray(gasPrice), BigIntegers.asUnsignedByteArray(gasLimit), toAddress == null ? null : Hex.decode(toAddress), BigIntegers.asUnsignedByteArray(value), data, null); return tx; } /** * 创建交易 * * @param nonce nonce * @param gasPrice gasPrice * @param gasLimit gasLimit * @param toAddress toAddress * @param value value * @param callFunc 调用合约方法 * @param funcArgs 合约参数（Int 数值请使用BigInteger或字符串） * @return 交易 */ public static EthTransaction createCallTransaction(BigInteger nonce, BigInteger gasPrice, BigInteger gasLimit, String toAddress, BigInteger value, Function callFunc, Object... funcArgs) { byte[] callData = callFunc.encode(funcArgs); return createRawTransaction(nonce, gasPrice, gasLimit, toAddress, value, callData); } @JsonInclude(JsonInclude.Include.NON_NULL) public static class Param { public Boolean indexed; public String name; public SolidityType type; @JsonGetter("type") public String getType() { return type.getName(); } } public enum FunctionType { constructor, function, event, fallback } public static class Function { public boolean anonymous; public boolean constant; public boolean payable; public String name = ""; public Param[] inputs = new Param[0]; public Param[] outputs = new Param[0]; public FunctionType type; private Function() { } public byte[] encode(Object... args) { return ByteUtil.merge(encodeSignature(), encodeArguments(args)); } public byte[] encodeArguments(Object... args) { if (args.length > inputs.length) throw new RuntimeException("Too many arguments: " + args.length + " > " + inputs.length); int staticSize = 0; int dynamicCnt = 0; // calculating static size and number of dynamic params for (int i = 0; i < args.length; i++) { Param param = inputs[i]; if (param.type.isDynamicType()) { dynamicCnt++; } staticSize += param.type.getFixedSize(); } byte[][] bb = new byte[args.length + dynamicCnt][]; int curDynamicPtr = staticSize; int curDynamicCnt = 0; for (int i = 0; i < args.length; i++) { if (inputs[i].type.isDynamicType()) { byte[] dynBB = inputs[i].type.encode(args[i]); bb[i] = SolidityType.IntType.encodeInt(curDynamicPtr); bb[args.length + curDynamicCnt] = dynBB; curDynamicCnt++; curDynamicPtr += dynBB.length; } else { bb[i] = inputs[i].type.encode(args[i]); } } return ByteUtil.merge(bb); } private Object[] decode(byte[] encoded, Param[] params) { Object[] ret = new Object[params.length]; int off = 0; for (int i = 0; i < params.length; i++) { if (params[i].type.isDynamicType()) { ret[i] = params[i].type.decode(encoded, IntType.decodeInt(encoded, off).intValue()); } else { ret[i] = params[i].type.decode(encoded, off); } off += params[i].type.getFixedSize(); } return ret; } public Object[] decode(byte[] encoded) { //import static org.apache.commons.lang3.ArrayUtils.subarray; //return decode(subarray(encoded, 4, encoded.length), inputs); return decode(ByteUtils.subArray(encoded, 4, encoded.length), inputs); } public Object[] decodeResult(byte[] encodedRet) { return decode(encodedRet, outputs); } public String formatSignature() { StringBuilder paramsTypes = new StringBuilder(); for (Param param : inputs) { paramsTypes.append(param.type.getCanonicalName()).append(","); } //import static org.apache.commons.lang3.StringUtils.stripEnd; //return format("%s(%s)", name, stripEnd(paramsTypes.toString(), ",")); return format("%s(%s)", name, stripEnd(paramsTypes.toString(), ",")); } public static String stripEnd(final String str, final String stripChars) { int end; if (str == null || (end = str.length()) == 0) { return str; } if (stripChars == null) { while (end != 0 && Character.isWhitespace(str.charAt(end - 1))) { end--; } } else if (stripChars.isEmpty()) { return str; } else { while (end != 0 && stripChars.indexOf(str.charAt(end - 1)) != -1) { end--; } } return str.substring(0, end); } public byte[] encodeSignatureLong() { String signature = formatSignature(); // byte[] sha3Fingerprint = sha3(signature.getSignBytes()); byte[] sha3Fingerprint = KECCAK256.keccak256(signature.getBytes()); return sha3Fingerprint; } public byte[] encodeSignature() { return Arrays.copyOfRange(encodeSignatureLong(), 0, 4); } @Override public String toString() { return formatSignature(); } public static Function fromJsonInterface(String json) { try { return DEFAULT_MAPPER.readValue(json, Function.class); } catch (IOException e) { throw new RuntimeException(e); } } public static Function fromSignature(String funcName, String... paramTypes) { return fromSignature(funcName, paramTypes, new String[0]); } public static Function fromSignature(String funcName, String[] paramTypes, String[] resultTypes) { Function ret = new Function(); ret.name = funcName; ret.constant = false; ret.type = FunctionType.function; ret.inputs = new Param[paramTypes.length]; for (int i = 0; i < paramTypes.length; i++) { ret.inputs[i] = new Param(); ret.inputs[i].name = "param" + i; ret.inputs[i].type = SolidityType.getType(paramTypes[i]); } ret.outputs = new Param[resultTypes.length]; for (int i = 0; i < resultTypes.length; i++) { ret.outputs[i] = new Param(); ret.outputs[i].name = "res" + i; ret.outputs[i].type = SolidityType.getType(resultTypes[i]); } return ret; } } public static class Contract { public Contract(String jsonInterface) { try { functions = new ObjectMapper().readValue(jsonInterface, Function[].class); } catch (IOException e) { throw new RuntimeException(e); } } public Function getByName(String name) { for (Function function : functions) { if (name.equals(function.name)) { return function; } } return null; } public Function getConstructor() { for (Function function : functions) { if (function.type == FunctionType.constructor) { return function; } } return null; } private Function getBySignatureHash(byte[] hash) { if (hash.length == 4) { for (Function function : functions) { if (FastByteComparisons.equal(function.encodeSignature(), hash)) { return function; } } } else if (hash.length == 32) { for (Function function : functions) { if (FastByteComparisons.equal(function.encodeSignatureLong(), hash)) { return function; } } } else { throw new RuntimeException("Function signature hash should be 4 or 32 bytes length"); } return null; } /** * Parses function and its arguments from transaction invocation binary data */ public Invocation parseInvocation(byte[] data) { if (data.length < 4) throw new RuntimeException("Invalid data length: " + data.length); Function function = getBySignatureHash(Arrays.copyOfRange(data, 0, 4)); if (function == null) throw new RuntimeException("Can't find function/event by it signature"); Object[] args = function.decode(data); return new Invocation(this, function, args); } /** * Parses Solidity Event and its data members from transaction receipt LogInfo */ public Invocation parseEvent(LogInfo eventLog) { Function event = getBySignatureHash(eventLog.getTopics().get(0).getData()); int indexedArg = 1; if (event == null) return null; List indexedArgs = new ArrayList<>(); List unindexed = new ArrayList<>(); for (Param input : event.inputs) { if (input.indexed) { indexedArgs.add(input.type.decode(eventLog.getTopics().get(indexedArg++).getData())); continue; } unindexed.add(input); } Object[] unindexedArgs = event.decode(eventLog.getData(), unindexed.toArray(new Param[unindexed.size()])); Object[] args = new Object[event.inputs.length]; int unindexedIndex = 0; int indexedIndex = 0; for (int i = 0; i < args.length; i++) { if (event.inputs[i].indexed) { args[i] = indexedArgs.get(indexedIndex++); continue; } args[i] = unindexedArgs[unindexedIndex++]; } return new Invocation(this, event, args); } public Function[] functions; } /** * Represents either function invocation with its arguments * or Event instance with its data members */ public static class Invocation { public final Contract contract; public final Function function; public final Object[] args; public Invocation(Contract contract, Function function, Object[] args) { this.contract = contract; this.function = function; this.args = args; } @Override public String toString() { return "[" + "contract=" + contract + (function.type == FunctionType.event ? ", event=" : ", function=") + function + ", args=" + Arrays.toString(args) + ']'; } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/ECDSASignature.java ================================================ package com.quincysx.crypto.ethereum; import com.quincysx.crypto.ethereum.config.Constants; import com.quincysx.crypto.utils.Base64; import org.spongycastle.asn1.ASN1InputStream; import org.spongycastle.asn1.ASN1Integer; import org.spongycastle.asn1.DLSequence; import org.spongycastle.asn1.sec.SECNamedCurves; import org.spongycastle.asn1.x9.X9ECParameters; import org.spongycastle.crypto.params.ECDomainParameters; import org.spongycastle.jce.spec.ECParameterSpec; import org.spongycastle.util.encoders.Hex; import java.io.IOException; import java.math.BigInteger; import java.security.SecureRandom; /** * @author QuincySx * @date 2018/3/6 上午9:46 */ public class ECDSASignature { /** * The parameters of the secp256k1 curve that Ethereum uses. */ public static final ECDomainParameters CURVE; public static final ECParameterSpec CURVE_SPEC; /** * Equal to CURVE.getN().shiftRight(1), used for canonicalising the S value of a signature. * ECDSA signatures are mutable in the sense that for a given (R, S) pair, * then both (R, S) and (R, N - S mod N) are valid signatures. * Canonical signatures are those where 1 <= S <= N/2 *

* See https://github.com/bitcoin/bips/blob/master/bip-0062.mediawiki#Low_S_values_in_signatures */ public static final BigInteger HALF_CURVE_ORDER; private static final SecureRandom secureRandom; static { // All clients must agree on the curve to use by agreement. Ethereum uses secp256k1. X9ECParameters params = SECNamedCurves.getByName("secp256k1"); CURVE = new ECDomainParameters(params.getCurve(), params.getG(), params.getN(), params.getH()); CURVE_SPEC = new ECParameterSpec(params.getCurve(), params.getG(), params.getN(), params.getH()); HALF_CURVE_ORDER = params.getN().shiftRight(1); secureRandom = new SecureRandom(); } /** * The two components of the signature. */ public final BigInteger r; public final BigInteger s; public byte v; /** * Constructs a signature with the given components. Does NOT automatically canonicalise the signature. * * @param r - * @param s - */ public ECDSASignature(BigInteger r, BigInteger s) { this.r = r; this.s = s; } /** * t * * @param r * @param s * @return - */ private static ECDSASignature fromComponents(byte[] r, byte[] s) { return new ECDSASignature(new BigInteger(1, r), new BigInteger(1, s)); } /** * @param r - * @param s - * @param v - * @return - */ public static ECDSASignature fromComponents(byte[] r, byte[] s, byte v) { ECDSASignature signature = fromComponents(r, s); signature.v = v; return signature; } public boolean validateComponents() { return validateComponents(r, s, v); } public static boolean validateComponents(BigInteger r, BigInteger s, byte v) { if (v != 27 && v != 28) return false; if (isLessThan(r, BigInteger.ONE)) return false; if (isLessThan(s, BigInteger.ONE)) return false; if (!isLessThan(r, Constants.getSECP256K1N())) return false; if (!isLessThan(s, Constants.getSECP256K1N())) return false; return true; } public static ECDSASignature decodeFromDER(byte[] bytes) { ASN1InputStream decoder = null; try { decoder = new ASN1InputStream(bytes); DLSequence seq = (DLSequence) decoder.readObject(); if (seq == null) throw new RuntimeException("Reached past end of ASN.1 stream."); ASN1Integer r, s; try { r = (ASN1Integer) seq.getObjectAt(0); s = (ASN1Integer) seq.getObjectAt(1); } catch (ClassCastException e) { throw new IllegalArgumentException(e); } // OpenSSL deviates from the DER spec by interpreting these values as unsigned, though they should not be // Thus, we always use the positive versions. See: http://r6.ca/blog/20111119T211504Z.html return new ECDSASignature(r.getPositiveValue(), s.getPositiveValue()); } catch (IOException e) { throw new RuntimeException(e); } finally { if (decoder != null) try { decoder.close(); } catch (IOException x) { } } } /** * Will automatically adjust the S component to be less than or equal to half the curve order, if necessary. * This is required because for every signature (r,s) the signature (r, -s (mod N)) is a valid signature of * the same message. However, we dislike the ability to modify the bits of a Ethereum transaction after it's * been signed, as that violates various assumed invariants. Thus in future only one of those forms will be * considered legal and the other will be banned. * * @return - */ public ECDSASignature toCanonicalised() { if (s.compareTo(HALF_CURVE_ORDER) > 0) { // The order of the curve is the number of valid points that exist on that curve. If S is in the upper // half of the number of valid points, then bring it back to the lower half. Otherwise, imagine that // N = 10 // s = 8, so (-8 % 10 == 2) thus both (r, 8) and (r, 2) are valid solutions. // 10 - 8 == 2, giving us always the latter solution, which is canonical. return new ECDSASignature(r, CURVE.getN().subtract(s)); } else { return this; } } /** * @return - */ public String toBase64() { byte[] sigData = new byte[65]; // 1 header + 32 bytes for R + 32 bytes for S sigData[0] = v; System.arraycopy(bigIntegerToBytes(this.r, 32), 0, sigData, 1, 32); System.arraycopy(bigIntegerToBytes(this.s, 32), 0, sigData, 33, 32); return Base64.encode(sigData); } public byte[] toByteArray() { final byte fixedV = this.v >= 27 ? (byte) (this.v - 27) : this.v; return merge( bigIntegerToBytes(this.r), bigIntegerToBytes(this.s), new byte[]{fixedV}); } public String toHex() { return Hex.toHexString(toByteArray()); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ECDSASignature signature = (ECDSASignature) o; if (!r.equals(signature.r)) return false; if (!s.equals(signature.s)) return false; return true; } public static byte[] bigIntegerToBytes(BigInteger b, int numBytes) { if (b == null) return null; byte[] bytes = new byte[numBytes]; byte[] biBytes = b.toByteArray(); int start = (biBytes.length == numBytes + 1) ? 1 : 0; int length = Math.min(biBytes.length, numBytes); System.arraycopy(biBytes, start, bytes, numBytes - length, length); return bytes; } public static byte[] merge(byte[]... arrays) { int arrCount = 0; int count = 0; for (byte[] array : arrays) { arrCount++; count += array.length; } // Create new array and copy all array contents byte[] mergedArray = new byte[count]; int start = 0; for (byte[] array : arrays) { System.arraycopy(array, 0, mergedArray, start, array.length); start += array.length; } return mergedArray; } public static byte[] bigIntegerToBytes(BigInteger value) { if (value == null) return null; byte[] data = value.toByteArray(); if (data.length != 1 && data[0] == 0) { byte[] tmp = new byte[data.length - 1]; System.arraycopy(data, 1, tmp, 0, tmp.length); data = tmp; } return data; } /** * Cast hex encoded value from byte[] to BigInteger * null is parsed like byte[0] * * @param bb byte array contains the values * @return unsigned positive BigInteger value. */ public static BigInteger bytesToBigInteger(byte[] bb) { return (bb == null || bb.length == 0) ? BigInteger.ZERO : new BigInteger(1, bb); } public static boolean isLessThan(BigInteger valueA, BigInteger valueB) { return valueA.compareTo(valueB) < 0; } @Override public int hashCode() { int result = r.hashCode(); result = 31 * result + s.hashCode(); return result; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/EthECKeyPair.java ================================================ package com.quincysx.crypto.ethereum; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.Key; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.eip55.EthCheckAddress; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.KECCAK256; import org.spongycastle.asn1.x9.X9IntegerConverter; import org.spongycastle.crypto.digests.SHA256Digest; import org.spongycastle.crypto.params.ECPrivateKeyParameters; import org.spongycastle.crypto.signers.ECDSASigner; import org.spongycastle.crypto.signers.HMacDSAKCalculator; import org.spongycastle.math.ec.ECAlgorithms; import org.spongycastle.math.ec.ECCurve; import org.spongycastle.math.ec.ECPoint; import java.math.BigInteger; /** * @author QuincySx * @date 2018/3/7 下午5:51 */ public class EthECKeyPair extends ECKeyPair { public static EthECKeyPair parse(Key keyPair) { return new EthECKeyPair(keyPair); } public EthECKeyPair(byte[] p) throws ValidationException { super(p, true); } public EthECKeyPair(BigInteger priv) { super(priv, true); } public EthECKeyPair(Key keyPair) { super(keyPair); } @Override public byte[] getRawPrivateKey() { return super.getRawPrivateKey(); } @Override public String getPrivateKey() { return HexUtils.toHex(getRawPrivateKey()); } @Override public byte[] getRawPublicKey() { byte[] publicKey = new byte[pub.length - 1]; System.arraycopy(pub, 1, publicKey, 0, publicKey.length); return publicKey; } @Override public String getPublicKey() { return HexUtils.toHex(getRawPublicKey()); } @Override public byte[] getRawAddress() { byte[] byteAddress = KECCAK256.keccak256(getRawPublicKey()); byte[] address = new byte[20]; System.arraycopy(byteAddress, 12, address, 0, address.length); return address; } @Override public String getAddress() { return EthCheckAddress.toChecksumAddress(HexUtils.toHex(getRawAddress())); } public ECDSASignature doSign(byte[] input) { if (input.length != 32) { throw new IllegalArgumentException("Expected 32 byte input to ECDSA signature, not " + input.length); } // No decryption of private key required. ECDSASigner signer = new ECDSASigner(new HMacDSAKCalculator(new SHA256Digest())); ECPrivateKeyParameters privKeyParams = new ECPrivateKeyParameters(priv, domain); signer.init(true, privKeyParams); BigInteger[] components = signer.generateSignature(input); return new ECDSASignature(components[0], components[1]).toCanonicalised(); } public ECDSASignature sign(byte[] messageHash) { ECDSASignature sig = doSign(messageHash); // Now we have to work backwards to figure out the recId needed to recover the signature. int recId = -1; for (int i = 0; i < 4; i++) { byte[] k = recoverPubBytesFromSignature(i, sig, messageHash); if (k != null && java.util.Arrays.equals(k, pub)) { recId = i; break; } } if (recId == -1) throw new RuntimeException("Could not construct a recoverable key. This should never " + "happen."); sig.v = (byte) (recId + 27); return sig; } public static byte[] recoverPubBytesFromSignature(int recId, ECDSASignature sig, byte[] messageHash) { check(recId >= 0, "recId must be positive"); check(sig.r.signum() >= 0, "r must be positive"); check(sig.s.signum() >= 0, "s must be positive"); check(messageHash != null, "messageHash must not be null"); // 1.0 For j from 0 to h (h == recId here and the loop is outside this function) // 1.1 Let x = r + jn BigInteger n = CURVE.getN(); // Curve order. BigInteger i = BigInteger.valueOf((long) recId / 2); BigInteger x = sig.r.add(i.multiply(n)); // 1.2. Convert the integer x to an octet string X of length mlen using the conversion // routine // specified in Section 2.3.7, where mlen = ⌈(log2 p)/8⌉ or mlen = ⌈m/8⌉. // 1.3. Convert the octet string (16 set binary digits)||X to an elliptic curve point R // using the // conversion routine specified in Section 2.3.4. If this conversion routine // outputs “invalid”, then // do another iteration of Step 1. // // More concisely, what these points mean is to use X as a compressed public key. ECCurve.Fp curve = (ECCurve.Fp) CURVE.getCurve(); BigInteger prime = curve.getQ(); // Bouncy Castle is not consistent about the letter it // uses for the prime. if (x.compareTo(prime) >= 0) { // Cannot have point co-ordinates larger than this as everything takes place modulo Q. return null; } // Compressed keys require you to know an extra bit of data about the y-coord as there // are two possibilities. // So it's encoded in the recId. ECPoint R = decompressKey(x, (recId & 1) == 1); // 1.4. If nR != point at infinity, then do another iteration of Step 1 (callers // responsibility). if (!R.multiply(n).isInfinity()) return null; // 1.5. Compute e from M using Steps 2 and 3 of ECDSA signature verification. BigInteger e = new BigInteger(1, messageHash); // 1.6. For k from 1 to 2 do the following. (loop is outside this function via // iterating recId) // 1.6.1. Compute a candidate public key as: // Q = mi(r) * (sR - eG) // // Where mi(x) is the modular multiplicative inverse. We transform this into the following: // Q = (mi(r) * s ** R) + (mi(r) * -e ** G) // Where -e is the modular additive inverse of e, that is z such that z + e = 0 (mod n). // In the above equation // ** is point multiplication and + is point addition (the EC group operator). // // We can find the additive inverse by subtracting e from zero then taking the mod. For // example the additive // inverse of 3 modulo 11 is 8 because 3 + 8 mod 11 = 0, and -3 mod 11 = 8. BigInteger eInv = BigInteger.ZERO.subtract(e).mod(n); BigInteger rInv = sig.r.modInverse(n); BigInteger srInv = rInv.multiply(sig.s).mod(n); BigInteger eInvrInv = rInv.multiply(eInv).mod(n); ECPoint.Fp q = (ECPoint.Fp) ECAlgorithms.sumOfTwoMultiplies(CURVE.getG(), eInvrInv, R, srInv); return q.getEncoded(/* compressed */ false); } private static ECPoint decompressKey(BigInteger xBN, boolean yBit) { X9IntegerConverter x9 = new X9IntegerConverter(); byte[] compEnc = x9.integerToBytes(xBN, 1 + x9.getByteLength(CURVE.getCurve())); compEnc[0] = (byte) (yBit ? 0x03 : 0x02); return CURVE.getCurve().decodePoint(compEnc); } private static void check(boolean test, String message) { if (!test) throw new IllegalArgumentException(message); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/EthTransaction.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum; import android.util.Log; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.Transaction; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.ethereum.rlp.RLP; import com.quincysx.crypto.ethereum.rlp.RLPElement; import com.quincysx.crypto.ethereum.rlp.RLPItem; import com.quincysx.crypto.ethereum.rlp.RLPList; import com.quincysx.crypto.ethereum.utils.ByteUtil; import com.quincysx.crypto.utils.KECCAK256; import org.spongycastle.util.BigIntegers; import org.spongycastle.util.encoders.Hex; import java.math.BigInteger; import java.util.Arrays; import static com.cedarsoftware.util.ArrayUtilities.isEmpty; import static com.quincysx.crypto.ethereum.utils.ByteUtil.EMPTY_BYTE_ARRAY; import static com.quincysx.crypto.ethereum.utils.ByteUtil.ZERO_BYTE_ARRAY; /** * A transaction (formally, T) is a single cryptographically * signed instruction sent by an actor external to Ethereum. * An external actor can be a person (via a mobile device or desktop computer) * or could be from a piece of automated software running on a server. * There are two types of transactions: those which result in message calls * and those which result in the creation of new contracts. */ public class EthTransaction implements Transaction { // private static final Logger logger = LoggerFactory.getLogger(EthTransaction.class); private static final BigInteger DEFAULT_GAS_PRICE = new BigInteger("10000000000000"); private static final BigInteger DEFAULT_BALANCE_GAS = new BigInteger("21000"); public static final int HASH_LENGTH = 32; public static final int ADDRESS_LENGTH = 20; /* SHA3 hash of the RLP encoded transaction */ private byte[] hash; /* a counter used to make sure each transaction can only be processed once */ private byte[] nonce; /* the amount of ether to transfer (calculated as wei) */ private byte[] value; /* the address of the destination account * In creation transaction the receive address is - 0 */ private byte[] receiveAddress; /* the amount of ether to pay as a transaction fee * to the miner for each unit of gas */ private byte[] gasPrice; /* the amount of "gas" to allow for the computation. * Gas is the fuel of the computational engine; * every computational step taken and every byte added * to the state or transaction list consumes some gas. */ private byte[] gasLimit; /* An unlimited size byte array specifying * input [data] of the message call or * Initialization code for a new contract */ private byte[] data; /** * Since EIP-155, we could encode chainId in V */ private static final int CHAIN_ID_INC = 35; private static final int LOWER_REAL_V = 27; private Integer chainId = null; /* the elliptic curve signature * (including public key recovery bits) */ private ECDSASignature signature; protected byte[] sendAddress; /* Tx in encoded form */ protected byte[] rlpEncoded; private byte[] rlpRaw; /* Indicates if this transaction has been parsed * from the RLP-encoded data */ protected boolean parsed = false; public EthTransaction(byte[] rawData) { this.rlpEncoded = rawData; parsed = false; } public EthTransaction(byte[] nonce, byte[] gasPrice, byte[] gasLimit, byte[] receiveAddress, byte[] value, byte[] data, Integer chainId) { this.nonce = nonce; this.gasPrice = gasPrice; this.gasLimit = gasLimit; this.receiveAddress = receiveAddress; if (ByteUtil.isSingleZero(value)) { this.value = EMPTY_BYTE_ARRAY; } else { this.value = value; } this.data = data; this.chainId = chainId; if (receiveAddress == null) { this.receiveAddress = EMPTY_BYTE_ARRAY; } parsed = true; } /** * Warning: this transaction would not be protected by replay-attack protection mechanism * Use * {@link EthTransaction#EthTransaction(byte[], byte[], byte[], byte[], byte[], byte[], Integer)} constructor instead * and specify the desired chainID */ public EthTransaction(byte[] nonce, byte[] gasPrice, byte[] gasLimit, byte[] receiveAddress, byte[] value, byte[] data) { this(nonce, gasPrice, gasLimit, receiveAddress, value, data, null); } public EthTransaction(byte[] nonce, byte[] gasPrice, byte[] gasLimit, byte[] receiveAddress, byte[] value, byte[] data, byte[] r, byte[] s, byte v, Integer chainId) { this(nonce, gasPrice, gasLimit, receiveAddress, value, data, chainId); this.signature = ECDSASignature.fromComponents(r, s, v); } /** * Warning: this transaction would not be protected by replay-attack protection mechanism * Use * {@link EthTransaction#EthTransaction(byte[], byte[], byte[], byte[], byte[], byte[], byte[], byte[], byte, Integer)} * constructor instead and specify the desired chainID */ public EthTransaction(byte[] nonce, byte[] gasPrice, byte[] gasLimit, byte[] receiveAddress, byte[] value, byte[] data, byte[] r, byte[] s, byte v) { this(nonce, gasPrice, gasLimit, receiveAddress, value, data, r, s, v, null); } private Integer extractChainIdFromV(BigInteger bv) { if (bv.bitLength() > 31) return Integer.MAX_VALUE; // chainId is limited to 31 bits, longer are not valid for now long v = bv.longValue(); if (v == LOWER_REAL_V || v == (LOWER_REAL_V + 1)) return null; return (int) ((v - CHAIN_ID_INC) / 2); } private byte getRealV(BigInteger bv) { if (bv.bitLength() > 31) return 0; // chainId is limited to 31 bits, longer are not valid for now long v = bv.longValue(); if (v == LOWER_REAL_V || v == (LOWER_REAL_V + 1)) return (byte) v; byte realV = LOWER_REAL_V; int inc = 0; if ((int) v % 2 == 0) inc = 1; return (byte) (realV + inc); } // public long transactionCost(BlockchainNetConfig config, Block block){ // // rlpParse(); // // return config.getConfigForBlock(block.getNumber()). // getTransactionCost(this); // } public synchronized void verify() { rlpParse(); validate(); } public synchronized void rlpParse() { if (parsed) return; try { RLPList decodedTxList = RLP.decode2(rlpEncoded); RLPList transaction = (RLPList) decodedTxList.get(0); // Basic verification if (transaction.size() > 9) throw new RuntimeException("Too many RLP elements"); for (RLPElement rlpElement : transaction) { if (!(rlpElement instanceof RLPItem)) throw new RuntimeException("EthTransaction RLP elements shouldn't be lists"); } this.nonce = transaction.get(0).getRLPData(); this.gasPrice = transaction.get(1).getRLPData(); this.gasLimit = transaction.get(2).getRLPData(); this.receiveAddress = transaction.get(3).getRLPData(); this.value = transaction.get(4).getRLPData(); this.data = transaction.get(5).getRLPData(); // only parse signature in case tx is signed if (transaction.get(6).getRLPData() != null) { byte[] vData = transaction.get(6).getRLPData(); BigInteger v = ByteUtil.bytesToBigInteger(vData); this.chainId = extractChainIdFromV(v); byte[] r = transaction.get(7).getRLPData(); byte[] s = transaction.get(8).getRLPData(); this.signature = ECDSASignature.fromComponents(r, s, getRealV(v)); } else { Log.e("=====", "RLP encoded tx is not signed!"); } this.parsed = true; this.hash = getHash(); } catch (Exception e) { throw new RuntimeException("Error on parsing RLP", e); } } private void validate() { if (getNonce().length > HASH_LENGTH) throw new RuntimeException("Nonce is not valid"); if (receiveAddress != null && receiveAddress.length != 0 && receiveAddress.length != ADDRESS_LENGTH) throw new RuntimeException("Receive address is not valid"); if (gasLimit.length > HASH_LENGTH) throw new RuntimeException("Gas Limit is not valid"); if (gasPrice != null && gasPrice.length > HASH_LENGTH) throw new RuntimeException("Gas Price is not valid"); if (value != null && value.length > HASH_LENGTH) throw new RuntimeException("Value is not valid"); if (getSignature() != null) { if (BigIntegers.asUnsignedByteArray(signature.r).length > HASH_LENGTH) throw new RuntimeException("Signature R is not valid"); if (BigIntegers.asUnsignedByteArray(signature.s).length > HASH_LENGTH) throw new RuntimeException("Signature S is not valid"); // if (getSender() != null && getSender().length != ADDRESS_LENGTH) // throw new RuntimeException("Sender is not valid"); } } public boolean isParsed() { return parsed; } public byte[] getHash() { if (!isEmpty(hash)) return hash; rlpParse(); byte[] plainMsg = this.getEncoded(); // return HashUtil.sha3(plainMsg); return KECCAK256.keccak256(plainMsg); // return SHA3Digest } public byte[] getRawHash() { rlpParse(); byte[] plainMsg = this.getEncodedRaw(); // return HashUtil.sha3(plainMsg); return KECCAK256.keccak256(plainMsg); } public byte[] getNonce() { rlpParse(); return nonce == null ? ZERO_BYTE_ARRAY : nonce; } protected void setNonce(byte[] nonce) { this.nonce = nonce; parsed = true; } public boolean isValueTx() { rlpParse(); return value != null; } public byte[] getValue() { rlpParse(); return value == null ? ZERO_BYTE_ARRAY : value; } protected void setValue(byte[] value) { this.value = value; parsed = true; } public byte[] getReceiveAddress() { rlpParse(); return receiveAddress; } protected void setReceiveAddress(byte[] receiveAddress) { this.receiveAddress = receiveAddress; parsed = true; } public byte[] getGasPrice() { rlpParse(); return gasPrice == null ? ZERO_BYTE_ARRAY : gasPrice; } protected void setGasPrice(byte[] gasPrice) { this.gasPrice = gasPrice; parsed = true; } public byte[] getGasLimit() { rlpParse(); return gasLimit == null ? ZERO_BYTE_ARRAY : gasLimit; } protected void setGasLimit(byte[] gasLimit) { this.gasLimit = gasLimit; parsed = true; } public long nonZeroDataBytes() { if (data == null) return 0; int counter = 0; for (final byte aData : data) { if (aData != 0) ++counter; } return counter; } public long zeroDataBytes() { if (data == null) return 0; int counter = 0; for (final byte aData : data) { if (aData == 0) ++counter; } return counter; } public byte[] getData() { rlpParse(); return data; } protected void setData(byte[] data) { this.data = data; parsed = true; } public ECDSASignature getSignature() { rlpParse(); return signature; } // public byte[] getContractAddress() { // if (!isContractCreation()) return null; // return calcNewAddr(this.getSender(), this.getNonce()); // } // // public static byte[] sha3omit12(byte[] input) { // byte[] hash = sha3(input); // return copyOfRange(hash, 12, hash.length); // } // // public static byte[] calcNewAddr(byte[] addr, byte[] nonce) { // // byte[] encSender = RLP.encodeElement(addr); // byte[] encNonce = RLP.encodeBigInteger(new BigInteger(1, nonce)); // // return sha3omit12(RLP.encodeList(encSender, encNonce)); // } public boolean isContractCreation() { rlpParse(); return this.receiveAddress == null || Arrays.equals(this.receiveAddress, EMPTY_BYTE_ARRAY); } /* * Crypto */ // public ECKey getKey() { // byte[] hash = getRawHash(); // return ECKey.recoverFromSignature(signature.v, signature, hash); // } // // public synchronized byte[] getSender() { // try { // if (sendAddress == null && getSignature() != null) { // sendAddress = ECKey.signatureToAddress(getRawHash(), getSignature()); // } // return sendAddress; // } catch (SignatureException e) { // Log.e(e.getMessage(), e); // } // return null; // } public Integer getChainId() { rlpParse(); return chainId == null ? null : (int) chainId; } // /** // * @deprecated should prefer #sign(ECKey) over this method // */ // public void sign(byte[] privKeyBytes) { // sign(ECKeyPair.fromPrivate(privKeyBytes)); // } @Override public byte[] sign(ECKeyPair key) throws ValidationException { this.signature = key.sign(this.getRawHash()); this.rlpEncoded = null; return getSignBytes(); } @Override public byte[] getSignBytes() { return getEncoded(); } @Override public String toString() { return toString(Integer.MAX_VALUE); } public String toString(int maxDataSize) { rlpParse(); String dataS; if (data == null) { dataS = ""; } else if (data.length < maxDataSize) { dataS = ByteUtil.toHexString(data); } else { dataS = ByteUtil.toHexString(Arrays.copyOfRange(data, 0, maxDataSize)) + "... (" + data.length + " bytes)"; } return "TransactionData [" + "hash=" + ByteUtil.toHexString(hash) + " nonce=" + ByteUtil.toHexString(nonce) + ", gasPrice=" + ByteUtil.toHexString(gasPrice) + ", gas=" + ByteUtil.toHexString(gasLimit) + ", receiveAddress=" + ByteUtil.toHexString(receiveAddress) + // ", sendAddress=" + ByteUtil.toHexString(getSender()) + ", value=" + ByteUtil.toHexString(value) + ", data=" + dataS + ", signatureV=" + (signature == null ? "" : signature.v) + ", signatureR=" + (signature == null ? "" : ByteUtil.toHexString(BigIntegers .asUnsignedByteArray(signature.r))) + ", signatureS=" + (signature == null ? "" : ByteUtil.toHexString(BigIntegers .asUnsignedByteArray(signature.s))) + "]"; } /** * For signatures you have to keep also * RLP of the transaction without any signature data */ public byte[] getEncodedRaw() { rlpParse(); if (rlpRaw != null) return rlpRaw; // parse null as 0 for nonce byte[] nonce = null; if (this.nonce == null || this.nonce.length == 1 && this.nonce[0] == 0) { nonce = RLP.encodeElement(null); } else { nonce = RLP.encodeElement(this.nonce); } byte[] gasPrice = RLP.encodeElement(this.gasPrice); byte[] gasLimit = RLP.encodeElement(this.gasLimit); byte[] receiveAddress = RLP.encodeElement(this.receiveAddress); byte[] value = RLP.encodeElement(this.value); byte[] data = RLP.encodeElement(this.data); // Since EIP-155 use chainId for v if (chainId == null) { rlpRaw = RLP.encodeList(nonce, gasPrice, gasLimit, receiveAddress, value, data); } else { byte[] v, r, s; v = RLP.encodeInt(chainId); r = RLP.encodeElement(EMPTY_BYTE_ARRAY); s = RLP.encodeElement(EMPTY_BYTE_ARRAY); rlpRaw = RLP.encodeList(nonce, gasPrice, gasLimit, receiveAddress, value, data, v, r, s); } return rlpRaw; } public void setSignature(ECDSASignature signature) { this.signature = signature; } public byte[] getEncoded() { if (rlpEncoded != null) return rlpEncoded; // parse null as 0 for nonce byte[] nonce = null; if (this.nonce == null || this.nonce.length == 1 && this.nonce[0] == 0) { nonce = RLP.encodeElement(null); } else { nonce = RLP.encodeElement(this.nonce); } byte[] gasPrice = RLP.encodeElement(this.gasPrice); byte[] gasLimit = RLP.encodeElement(this.gasLimit); byte[] receiveAddress = RLP.encodeElement(this.receiveAddress); byte[] value = RLP.encodeElement(this.value); byte[] data = RLP.encodeElement(this.data); byte[] v, r, s; if (signature != null) { int encodeV; if (chainId == null) { encodeV = signature.v; } else { encodeV = signature.v - LOWER_REAL_V; encodeV += chainId * 2 + CHAIN_ID_INC; } v = RLP.encodeInt(encodeV); r = RLP.encodeElement(BigIntegers.asUnsignedByteArray(signature.r)); s = RLP.encodeElement(BigIntegers.asUnsignedByteArray(signature.s)); } else { // Since EIP-155 use chainId for v v = chainId == null ? RLP.encodeElement(EMPTY_BYTE_ARRAY) : RLP.encodeInt(chainId); r = RLP.encodeElement(EMPTY_BYTE_ARRAY); s = RLP.encodeElement(EMPTY_BYTE_ARRAY); } this.rlpEncoded = RLP.encodeList(nonce, gasPrice, gasLimit, receiveAddress, value, data, v, r, s); this.hash = this.getHash(); return rlpEncoded; } @Override public int hashCode() { byte[] hash = this.getHash(); int hashCode = 0; for (int i = 0; i < hash.length; ++i) { hashCode += hash[i] * i; } return hashCode; } @Override public boolean equals(Object obj) { if (!(obj instanceof EthTransaction)) return false; EthTransaction tx = (EthTransaction) obj; return tx.hashCode() == this.hashCode(); } /** * @deprecated Use * {@link EthTransaction#createDefault(String, BigInteger, BigInteger, Integer)} instead */ public static EthTransaction createDefault(String to, BigInteger amount, BigInteger nonce) { return create(to, amount, nonce, DEFAULT_GAS_PRICE, DEFAULT_BALANCE_GAS); } public static EthTransaction createDefault(String to, BigInteger amount, BigInteger nonce, Integer chainId) { return create(to, amount, nonce, DEFAULT_GAS_PRICE, DEFAULT_BALANCE_GAS, chainId); } /** * @deprecated use * {@link EthTransaction#create(String, BigInteger, BigInteger, BigInteger, BigInteger, Integer)} instead */ public static EthTransaction create(String to, BigInteger amount, BigInteger nonce, BigInteger gasPrice, BigInteger gasLimit) { return new EthTransaction(BigIntegers.asUnsignedByteArray(nonce), BigIntegers.asUnsignedByteArray(gasPrice), BigIntegers.asUnsignedByteArray(gasLimit), Hex.decode(to), BigIntegers.asUnsignedByteArray(amount), null); } public static EthTransaction create(String to, BigInteger amount, BigInteger nonce, BigInteger gasPrice, BigInteger gasLimit, Integer chainId) { return new EthTransaction(BigIntegers.asUnsignedByteArray(nonce), BigIntegers.asUnsignedByteArray(gasPrice), BigIntegers.asUnsignedByteArray(gasLimit), Hex.decode(to), BigIntegers.asUnsignedByteArray(amount), null, chainId); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/config/Constants.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.config; import java.math.BigInteger; /** * Describes different constants specific for a blockchain * * Created by Anton Nashatyrev on 25.02.2016. */ public class Constants { private static final int MAXIMUM_EXTRA_DATA_SIZE = 32; private static final int MIN_GAS_LIMIT = 125000; private static final int GAS_LIMIT_BOUND_DIVISOR = 1024; private static final BigInteger MINIMUM_DIFFICULTY = BigInteger.valueOf(131072); private static final BigInteger DIFFICULTY_BOUND_DIVISOR = BigInteger.valueOf(2048); private static final int EXP_DIFFICULTY_PERIOD = 100000; private static final int UNCLE_GENERATION_LIMIT = 7; private static final int UNCLE_LIST_LIMIT = 2; private static final int BEST_NUMBER_DIFF_LIMIT = 100; private static final BigInteger BLOCK_REWARD = new BigInteger("1500000000000000000"); private static final BigInteger SECP256K1N = new BigInteger("fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141", 16); public int getDURATION_LIMIT() { return 8; } public BigInteger getInitialNonce() { return BigInteger.ZERO; } public int getMAXIMUM_EXTRA_DATA_SIZE() { return MAXIMUM_EXTRA_DATA_SIZE; } public int getMIN_GAS_LIMIT() { return MIN_GAS_LIMIT; } public int getGAS_LIMIT_BOUND_DIVISOR() { return GAS_LIMIT_BOUND_DIVISOR; } public BigInteger getMINIMUM_DIFFICULTY() { return MINIMUM_DIFFICULTY; } public BigInteger getDIFFICULTY_BOUND_DIVISOR() { return DIFFICULTY_BOUND_DIVISOR; } public int getEXP_DIFFICULTY_PERIOD() { return EXP_DIFFICULTY_PERIOD; } public int getUNCLE_GENERATION_LIMIT() { return UNCLE_GENERATION_LIMIT; } public int getUNCLE_LIST_LIMIT() { return UNCLE_LIST_LIMIT; } public int getBEST_NUMBER_DIFF_LIMIT() { return BEST_NUMBER_DIFF_LIMIT; } public BigInteger getBLOCK_REWARD() { return BLOCK_REWARD; } public int getMAX_CONTRACT_SZIE() { return Integer.MAX_VALUE; } /** * Introduced in the Homestead release */ public boolean createEmptyContractOnOOG() { return true; } /** * New DELEGATECALL opcode introduced in the Homestead release. Before Homestead this opcode should generate * exception */ public boolean hasDelegateCallOpcode() {return false; } /** * Introduced in the Homestead release */ public static BigInteger getSECP256K1N() { return SECP256K1N; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/keystore/CipherException.java ================================================ package com.quincysx.crypto.ethereum.keystore; public class CipherException extends Exception { public CipherException(String message) { super(message); } public CipherException(Throwable cause) { super(cause); } public CipherException(String message, Throwable cause) { super(message, cause); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/keystore/KeyStore.java ================================================ package com.quincysx.crypto.ethereum.keystore; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.ethereum.EthECKeyPair; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.KECCAK256; import org.spongycastle.crypto.digests.SHA256Digest; import org.spongycastle.crypto.generators.PKCS5S2ParametersGenerator; import org.spongycastle.crypto.generators.SCrypt; import org.spongycastle.crypto.params.KeyParameter; import java.nio.charset.Charset; import java.security.InvalidAlgorithmParameterException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.util.Arrays; import java.util.UUID; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; public class KeyStore { private static final int N_LIGHT = 1 << 12; private static final int P_LIGHT = 6; private static final int N_STANDARD = 1 << 18; private static final int P_STANDARD = 1; private static final int R = 8; private static final int DKLEN = 32; private static final int CURRENT_VERSION = 3; private static final String CIPHER = "aes-128-ctr"; static final String AES_128_CTR = "pbkdf2"; static final String SCRYPT = "scrypt"; private static SecureRandom secureRandom = new SecureRandom(); public static KeyStoreFile createStandard(String password, EthECKeyPair ecKeyPair) throws CipherException { return create(password, ecKeyPair, N_STANDARD, P_STANDARD); } public static KeyStoreFile createLight(String password, EthECKeyPair ecKeyPair) throws CipherException { return create(password, ecKeyPair, N_LIGHT, P_LIGHT); } public static KeyStoreFile create(String password, EthECKeyPair ecKeyPair, int n, int p) throws CipherException { byte[] salt = generateRandomBytes(32); byte[] derivedKey = generateDerivedScryptKey( password.getBytes(Charset.forName("UTF-8")), salt, n, R, p, DKLEN); byte[] encryptKey = Arrays.copyOfRange(derivedKey, 0, 16); byte[] iv = generateRandomBytes(16); // byte[] privateKeyBytes = // Numeric.toBytesPadded(ecKeyPair.getPrivateKey(), Keys.PRIVATE_KEY_SIZE); byte[] privateKeyBytes = ecKeyPair.getRawPrivateKey(); byte[] cipherText = performCipherOperation( Cipher.ENCRYPT_MODE, iv, encryptKey, privateKeyBytes); byte[] mac = generateMac(derivedKey, cipherText); return createWalletFile(ecKeyPair, cipherText, iv, salt, mac, n, p); } private static byte[] performCipherOperation( int mode, byte[] iv, byte[] encryptKey, byte[] text) throws CipherException { try { IvParameterSpec ivParameterSpec = new IvParameterSpec(iv); Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding"); SecretKeySpec secretKeySpec = new SecretKeySpec(encryptKey, "AES"); cipher.init(mode, secretKeySpec, ivParameterSpec); return cipher.doFinal(text); } catch (NoSuchPaddingException | NoSuchAlgorithmException | InvalidAlgorithmParameterException | InvalidKeyException | BadPaddingException | IllegalBlockSizeException e) { throw new CipherException("Error performing cipher operation", e); } } private static byte[] generateMac(byte[] derivedKey, byte[] cipherText) { byte[] result = new byte[16 + cipherText.length]; System.arraycopy(derivedKey, 16, result, 0, 16); System.arraycopy(cipherText, 0, result, 16, cipherText.length); return KECCAK256.keccak256(result); // return Hash.sha3(result); } private static byte[] generateDerivedScryptKey( byte[] password, byte[] salt, int n, int r, int p, int dkLen) { return SCrypt.generate(password, salt, n, r, p, dkLen); } static byte[] generateRandomBytes(int size) { byte[] bytes = new byte[size]; secureRandom.nextBytes(bytes); return bytes; } private static KeyStoreFile createWalletFile( EthECKeyPair ecKeyPair, byte[] cipherText, byte[] iv, byte[] salt, byte[] mac, int n, int p) { KeyStoreFile walletFile = new KeyStoreFile(); walletFile.setAddress(ecKeyPair.getAddress()); KeyStoreFile.Crypto crypto = new KeyStoreFile.Crypto(); crypto.setCipher(CIPHER); // crypto.setCiphertext(Numeric.toHexStringNoPrefix(cipherText)); crypto.setCiphertext(HexUtils.toHex(cipherText)); walletFile.setCrypto(crypto); KeyStoreFile.CipherParams cipherParams = new KeyStoreFile.CipherParams(); // cipherParams.setIv(Numeric.toHexStringNoPrefix(iv)); cipherParams.setIv(HexUtils.toHex(iv)); crypto.setCipherparams(cipherParams); crypto.setKdf(SCRYPT); KeyStoreFile.ScryptKdfParams kdfParams = new KeyStoreFile.ScryptKdfParams(); kdfParams.setDklen(DKLEN); kdfParams.setN(n); kdfParams.setP(p); kdfParams.setR(R); // kdfParams.setSalt(Numeric.toHexStringNoPrefix(salt)); kdfParams.setSalt(HexUtils.toHex(salt)); crypto.setKdfparams(kdfParams); // crypto.setMac(Numeric.toHexStringNoPrefix(mac)); crypto.setMac(HexUtils.toHex(mac)); walletFile.setCrypto(crypto); walletFile.setId(UUID.randomUUID().toString()); walletFile.setVersion(CURRENT_VERSION); return walletFile; } static void validate(KeyStoreFile walletFile) throws CipherException { KeyStoreFile.Crypto crypto = walletFile.getCrypto(); if (walletFile.getVersion() != CURRENT_VERSION) { throw new CipherException("Wallet version is not supported"); } if (!crypto.getCipher().equals(CIPHER)) { throw new CipherException("Wallet cipher is not supported"); } if (!crypto.getKdf().equals(AES_128_CTR) && !crypto.getKdf().equals(SCRYPT)) { throw new CipherException("KDF type is not supported"); } } public static EthECKeyPair decrypt(String password, KeyStoreFile walletFile) throws CipherException, ValidationException { validate(walletFile); KeyStoreFile.Crypto crypto = walletFile.getCrypto(); byte[] mac = HexUtils.fromHex(crypto.getMac()); byte[] iv = HexUtils.fromHex(crypto.getCipherparams().getIv()); byte[] cipherText = HexUtils.fromHex(crypto.getCiphertext()); byte[] derivedKey; KeyStoreFile.KdfParams kdfParams = crypto.getKdfparams(); if (kdfParams instanceof KeyStoreFile.ScryptKdfParams) { KeyStoreFile.ScryptKdfParams scryptKdfParams = (KeyStoreFile.ScryptKdfParams) crypto.getKdfparams(); int dklen = scryptKdfParams.getDklen(); int n = scryptKdfParams.getN(); int p = scryptKdfParams.getP(); int r = scryptKdfParams.getR(); byte[] salt = HexUtils.fromHex(scryptKdfParams.getSalt()); // derivedKey = generateDerivedScryptKey(password.getBytes(Charset.forName("UTF-8")), // salt, n, r, p, dklen); derivedKey = com.lambdaworks.crypto.SCrypt.scryptN(password.getBytes(Charset.forName("UTF-8")), salt, n, r, p, dklen); } else if (kdfParams instanceof KeyStoreFile.Aes128CtrKdfParams) { KeyStoreFile.Aes128CtrKdfParams aes128CtrKdfParams = (KeyStoreFile.Aes128CtrKdfParams) crypto.getKdfparams(); int c = aes128CtrKdfParams.getC(); String prf = aes128CtrKdfParams.getPrf(); byte[] salt = HexUtils.fromHex(aes128CtrKdfParams.getSalt()); derivedKey = generateAes128CtrDerivedKey(password.getBytes(Charset.forName("UTF-8")), salt, c, prf); } else { throw new CipherException("Unable to deserialize params: " + crypto.getKdf()); } byte[] derivedMac = generateMac(derivedKey, cipherText); if (!Arrays.equals(derivedMac, mac)) { throw new CipherException("Invalid password provided"); } byte[] encryptKey = Arrays.copyOfRange(derivedKey, 0, 16); byte[] privateKey = performCipherOperation(Cipher.DECRYPT_MODE, iv, encryptKey, cipherText); return new EthECKeyPair(privateKey); } private static byte[] generateAes128CtrDerivedKey( byte[] password, byte[] salt, int c, String prf) throws CipherException { if (!prf.equals("hmac-sha256")) { throw new CipherException("Unsupported prf:" + prf); } // Java 8 supports this, but you have to convert the password to a character array, see // http://stackoverflow.com/a/27928435/3211687 PKCS5S2ParametersGenerator gen = new PKCS5S2ParametersGenerator(new SHA256Digest()); gen.init(password, salt, c); return ((KeyParameter) gen.generateDerivedParameters(256)).getKey(); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/keystore/KeyStoreFile.java ================================================ package com.quincysx.crypto.ethereum.keystore; import com.fasterxml.jackson.annotation.JsonSetter; import com.fasterxml.jackson.annotation.JsonSubTypes; import com.fasterxml.jackson.annotation.JsonTypeInfo; import com.fasterxml.jackson.core.JsonParser; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.DeserializationContext; import com.fasterxml.jackson.databind.JsonDeserializer; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.ObjectNode; import java.io.IOException; public class KeyStoreFile { private String address; private Crypto crypto; private String id; private int version; public KeyStoreFile() { } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } public Crypto getCrypto() { return crypto; } @JsonSetter("crypto") public void setCrypto(Crypto crypto) { this.crypto = crypto; } @JsonSetter("Crypto") // older wallet files may have this attribute name public void setCryptoV1(Crypto crypto) { setCrypto(crypto); } public String getId() { return id; } public void setId(String id) { this.id = id; } public int getVersion() { return version; } public void setVersion(int version) { this.version = version; } public static KeyStoreFile parse(String keystore) throws IOException { return new ObjectMapper().readValue (keystore, KeyStoreFile.class); } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof KeyStoreFile)) { return false; } KeyStoreFile that = (KeyStoreFile) o; if (getAddress() != null ? !getAddress().equals(that.getAddress()) : that.getAddress() != null) { return false; } if (getCrypto() != null ? !getCrypto().equals(that.getCrypto()) : that.getCrypto() != null) { return false; } if (getId() != null ? !getId().equals(that.getId()) : that.getId() != null) { return false; } return version == that.version; } @Override public int hashCode() { int result = getAddress() != null ? getAddress().hashCode() : 0; result = 31 * result + (getCrypto() != null ? getCrypto().hashCode() : 0); result = 31 * result + (getId() != null ? getId().hashCode() : 0); result = 31 * result + version; return result; } public static class Crypto { private String cipher; private String ciphertext; private CipherParams cipherparams; private String kdf; private KdfParams kdfparams; private String mac; public Crypto() { } public String getCipher() { return cipher; } public void setCipher(String cipher) { this.cipher = cipher; } public String getCiphertext() { return ciphertext; } public void setCiphertext(String ciphertext) { this.ciphertext = ciphertext; } public CipherParams getCipherparams() { return cipherparams; } public void setCipherparams(CipherParams cipherparams) { this.cipherparams = cipherparams; } public String getKdf() { return kdf; } public void setKdf(String kdf) { this.kdf = kdf; } public KdfParams getKdfparams() { return kdfparams; } @JsonTypeInfo( use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.EXTERNAL_PROPERTY, property = "kdf") @JsonSubTypes({ @JsonSubTypes.Type(value = Aes128CtrKdfParams.class, name = KeyStore.AES_128_CTR), @JsonSubTypes.Type(value = ScryptKdfParams.class, name = KeyStore.SCRYPT) }) // To support my Ether Wallet keys uncomment this annotation & comment out the above // @JsonDeserialize(using = KdfParamsDeserialiser.class) // Also add the following to the ObjectMapperFactory // objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true); public void setKdfparams(KdfParams kdfparams) { this.kdfparams = kdfparams; } public String getMac() { return mac; } public void setMac(String mac) { this.mac = mac; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof Crypto)) { return false; } Crypto that = (Crypto) o; if (getCipher() != null ? !getCipher().equals(that.getCipher()) : that.getCipher() != null) { return false; } if (getCiphertext() != null ? !getCiphertext().equals(that.getCiphertext()) : that.getCiphertext() != null) { return false; } if (getCipherparams() != null ? !getCipherparams().equals(that.getCipherparams()) : that.getCipherparams() != null) { return false; } if (getKdf() != null ? !getKdf().equals(that.getKdf()) : that.getKdf() != null) { return false; } if (getKdfparams() != null ? !getKdfparams().equals(that.getKdfparams()) : that.getKdfparams() != null) { return false; } return getMac() != null ? getMac().equals(that.getMac()) : that.getMac() == null; } @Override public int hashCode() { int result = getCipher() != null ? getCipher().hashCode() : 0; result = 31 * result + (getCiphertext() != null ? getCiphertext().hashCode() : 0); result = 31 * result + (getCipherparams() != null ? getCipherparams().hashCode() : 0); result = 31 * result + (getKdf() != null ? getKdf().hashCode() : 0); result = 31 * result + (getKdfparams() != null ? getKdfparams().hashCode() : 0); result = 31 * result + (getMac() != null ? getMac().hashCode() : 0); return result; } } public static class CipherParams { private String iv; public CipherParams() { } public String getIv() { return iv; } public void setIv(String iv) { this.iv = iv; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof CipherParams)) { return false; } CipherParams that = (CipherParams) o; return getIv() != null ? getIv().equals(that.getIv()) : that.getIv() == null; } @Override public int hashCode() { int result = getIv() != null ? getIv().hashCode() : 0; return result; } } interface KdfParams { int getDklen(); String getSalt(); } public static class Aes128CtrKdfParams implements KdfParams { private int dklen; private int c; private String prf; private String salt; public Aes128CtrKdfParams() { } public int getDklen() { return dklen; } public void setDklen(int dklen) { this.dklen = dklen; } public int getC() { return c; } public void setC(int c) { this.c = c; } public String getPrf() { return prf; } public void setPrf(String prf) { this.prf = prf; } public String getSalt() { return salt; } public void setSalt(String salt) { this.salt = salt; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof Aes128CtrKdfParams)) { return false; } Aes128CtrKdfParams that = (Aes128CtrKdfParams) o; if (dklen != that.dklen) { return false; } if (c != that.c) { return false; } if (getPrf() != null ? !getPrf().equals(that.getPrf()) : that.getPrf() != null) { return false; } return getSalt() != null ? getSalt().equals(that.getSalt()) : that.getSalt() == null; } @Override public int hashCode() { int result = dklen; result = 31 * result + c; result = 31 * result + (getPrf() != null ? getPrf().hashCode() : 0); result = 31 * result + (getSalt() != null ? getSalt().hashCode() : 0); return result; } } public static class ScryptKdfParams implements KdfParams { private int dklen; private int n; private int p; private int r; private String salt; public ScryptKdfParams() { } public int getDklen() { return dklen; } public void setDklen(int dklen) { this.dklen = dklen; } public int getN() { return n; } public void setN(int n) { this.n = n; } public int getP() { return p; } public void setP(int p) { this.p = p; } public int getR() { return r; } public void setR(int r) { this.r = r; } public String getSalt() { return salt; } public void setSalt(String salt) { this.salt = salt; } @Override public boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof ScryptKdfParams)) { return false; } ScryptKdfParams that = (ScryptKdfParams) o; if (dklen != that.dklen) { return false; } if (n != that.n) { return false; } if (p != that.p) { return false; } if (r != that.r) { return false; } return getSalt() != null ? getSalt().equals(that.getSalt()) : that.getSalt() == null; } @Override public int hashCode() { int result = dklen; result = 31 * result + n; result = 31 * result + p; result = 31 * result + r; result = 31 * result + (getSalt() != null ? getSalt().hashCode() : 0); return result; } } // If we need to work with MyEtherWallet we'll need to use this deserializer, see the // following issue https://github.com/kvhnuke/etherwallet/issues/269 static class KdfParamsDeserialiser extends JsonDeserializer { @Override public KdfParams deserialize( JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException { ObjectMapper objectMapper = (ObjectMapper) jsonParser.getCodec(); ObjectNode root = objectMapper.readTree(jsonParser); KdfParams kdfParams; // it would be preferable to detect the class to use based on the kdf parameter in the // container object instance JsonNode n = root.get("n"); if (n == null) { kdfParams = objectMapper.convertValue(root, Aes128CtrKdfParams.class); } else { kdfParams = objectMapper.convertValue(root, ScryptKdfParams.class); } return kdfParams; } } @Override public String toString() { ObjectMapper mapper = new ObjectMapper(); String mapJakcson = ""; try { mapJakcson = mapper.writeValueAsString(this); } catch (JsonProcessingException e) { e.printStackTrace(); } return mapJakcson; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/rlp/CompactEncoder.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.rlp; import com.quincysx.crypto.ethereum.utils.ByteUtil; import java.io.ByteArrayOutputStream; import java.nio.ByteBuffer; import java.util.Arrays; import java.util.HashMap; import java.util.Map; import static java.util.Arrays.*; import static org.spongycastle.util.Arrays.concatenate; import static org.spongycastle.util.encoders.Hex.encode; /** * Compact encoding of hex sequence with optional terminator *

* The traditional compact way of encoding a hex string is to convert it into binary * - that is, a string like 0f1248 would become three bytes 15, 18, 72. However, * this approach has one slight problem: what if the length of the hex string is odd? * In that case, there is no way to distinguish between, say, 0f1248 and f1248. *

* Additionally, our application in the Merkle Patricia tree requires the additional feature * that a hex string can also have a special "terminator symbol" at the end (denoted by the 'T'). * A terminator symbol can occur only once, and only at the end. *

* An alternative way of thinking about this to not think of there being a terminator symbol, * but instead treat bit specifying the existence of the terminator symbol as a bit specifying * that the given node encodes a final node, where the value is an actual value, rather than * the hash of yet another node. *

* To solve both of these issues, we force the first nibble of the final byte-stream to encode * two flags, specifying oddness of length (ignoring the 'T' symbol) and terminator status; * these are placed, respectively, into the two lowest significant bits of the first nibble. * In the case of an even-length hex string, we must introduce a second nibble (of value zero) * to ensure the hex-string is even in length and thus is representable by a whole number of bytes. *

* Examples: * > [ 1, 2, 3, 4, 5 ] * '\x11\x23\x45' * > [ 0, 1, 2, 3, 4, 5 ] * '\x00\x01\x23\x45' * > [ 0, 15, 1, 12, 11, 8, T ] * '\x20\x0f\x1c\xb8' * > [ 15, 1, 12, 11, 8, T ] * '\x3f\x1c\xb8' */ public class CompactEncoder { private final static byte TERMINATOR = 16; private final static Map hexMap = new HashMap<>(); static { hexMap.put('0', (byte) 0x0); hexMap.put('1', (byte) 0x1); hexMap.put('2', (byte) 0x2); hexMap.put('3', (byte) 0x3); hexMap.put('4', (byte) 0x4); hexMap.put('5', (byte) 0x5); hexMap.put('6', (byte) 0x6); hexMap.put('7', (byte) 0x7); hexMap.put('8', (byte) 0x8); hexMap.put('9', (byte) 0x9); hexMap.put('a', (byte) 0xa); hexMap.put('b', (byte) 0xb); hexMap.put('c', (byte) 0xc); hexMap.put('d', (byte) 0xd); hexMap.put('e', (byte) 0xe); hexMap.put('f', (byte) 0xf); } /** * Pack nibbles to binary * * @param nibbles sequence. may have a terminator * @return hex-encoded byte array */ public static byte[] packNibbles(byte[] nibbles) { int terminator = 0; if (nibbles[nibbles.length - 1] == TERMINATOR) { terminator = 1; nibbles = copyOf(nibbles, nibbles.length - 1); } int oddlen = nibbles.length % 2; int flag = 2 * terminator + oddlen; if (oddlen != 0) { byte[] flags = new byte[]{(byte) flag}; nibbles = concatenate(flags, nibbles); } else { byte[] flags = new byte[]{(byte) flag, 0}; nibbles = concatenate(flags, nibbles); } ByteArrayOutputStream buffer = new ByteArrayOutputStream(); for (int i = 0; i < nibbles.length; i += 2) { buffer.write(16 * nibbles[i] + nibbles[i + 1]); } return buffer.toByteArray(); } public static boolean hasTerminator(byte[] packedKey) { return ((packedKey[0] >> 4) & 2) != 0; } /** * Unpack a binary string to its nibbles equivalent * * @param str of binary data * @return array of nibbles in byte-format */ public static byte[] unpackToNibbles(byte[] str) { byte[] base = binToNibbles(str); base = copyOf(base, base.length - 1); if (base[0] >= 2) { base = ByteUtil.appendByte(base, TERMINATOR); } if (base[0] % 2 == 1) { base = copyOfRange(base, 1, base.length); } else { base = copyOfRange(base, 2, base.length); } return base; } /** * Transforms a binary array to hexadecimal format + terminator * * @param str byte[] * @return array with each individual nibble adding a terminator at the end */ public static byte[] binToNibbles(byte[] str) { byte[] hexEncoded = encode(str); byte[] hexEncodedTerminated = Arrays.copyOf(hexEncoded, hexEncoded.length + 1); for (int i = 0; i < hexEncoded.length; ++i) { byte b = hexEncodedTerminated[i]; hexEncodedTerminated[i] = hexMap.get((char) b); } hexEncodedTerminated[hexEncodedTerminated.length - 1] = TERMINATOR; return hexEncodedTerminated; } public static byte[] binToNibblesNoTerminator(byte[] str) { byte[] hexEncoded = encode(str); for (int i = 0; i < hexEncoded.length; ++i) { byte b = hexEncoded[i]; hexEncoded[i] = hexMap.get((char) b); } return hexEncoded; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/rlp/DecodeResult.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.rlp; import org.spongycastle.util.encoders.Hex; import java.io.Serializable; @SuppressWarnings("serial") public class DecodeResult implements Serializable { private int pos; private Object decoded; public DecodeResult(int pos, Object decoded) { this.pos = pos; this.decoded = decoded; } public int getPos() { return pos; } public Object getDecoded() { return decoded; } public String toString() { return asString(this.decoded); } private String asString(Object decoded) { if (decoded instanceof String) { return (String) decoded; } else if (decoded instanceof byte[]) { return Hex.toHexString((byte[]) decoded); } else if (decoded instanceof Object[]) { String result = ""; for (Object item : (Object[]) decoded) { result += asString(item); } return result; } throw new RuntimeException("Not a valid type. Should not occur"); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/rlp/RLP.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.rlp; import com.quincysx.crypto.ethereum.ByteArrayWrapper; import com.quincysx.crypto.ethereum.utils.ByteUtil; import org.spongycastle.util.Arrays; import org.spongycastle.util.encoders.Hex; import java.math.BigInteger; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Queue; import java.util.Set; import static com.quincysx.crypto.ethereum.utils.ByteUtil.*; import static org.spongycastle.util.Arrays.*; import static org.spongycastle.util.BigIntegers.*; /** * Recursive Length Prefix (RLP) encoding. *

* The purpose of RLP is to encode arbitrarily nested arrays of binary data, and * RLP is the main encoding method used to serialize objects in Ethereum. The * only purpose of RLP is to encode structure; encoding specific atomic data * types (eg. strings, integers, floats) is left up to higher-order protocols; in * Ethereum the standard is that integers are represented in big endian binary * form. If one wishes to use RLP to encode a dictionary, the two suggested * canonical forms are to either use [[k1,v1],[k2,v2]...] with keys in * lexicographic order or to use the higher-level Patricia Tree encoding as * Ethereum does. *

* The RLP encoding function takes in an item. An item is defined as follows: *

* - A string (ie. byte array) is an item - A list of items is an item *

* For example, an empty string is an item, as is the string containing the word * "cat", a list containing any number of strings, as well as more complex data * structures like ["cat",["puppy","cow"],"horse",[[]],"pig",[""],"sheep"]. Note * that in the context of the rest of this article, "string" will be used as a * synonym for "a certain number of bytes of binary data"; no special encodings * are used and no knowledge about the content of the strings is implied. *

* See: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP * * @author Roman Mandeleil * @since 01.04.2014 */ public class RLP { // private static final Logger logger = LoggerFactory.getLogger("rlp"); public static final byte[] EMPTY_ELEMENT_RLP = encodeElement(new byte[0]); /** * Allow for content up to size of 2^64 bytes * */ private static final double MAX_ITEM_LENGTH = Math.pow(256, 8); /** * Reason for threshold according to Vitalik Buterin: * - 56 bytes maximizes the benefit of both options * - if we went with 60 then we would have only had 4 slots for long strings * so RLP would not have been able to store objects above 4gb * - if we went with 48 then RLP would be fine for 2^128 space, but that's way too much * - so 56 and 2^64 space seems like the right place to put the cutoff * - also, that's where Bitcoin's varint does the cutof */ private static final int SIZE_THRESHOLD = 56; /** RLP encoding rules are defined as follows: */ /* * For a single byte whose value is in the [0x00, 0x7f] range, that byte is * its own RLP encoding. */ /** * [0x80] * If a string is 0-55 bytes long, the RLP encoding consists of a single * byte with value 0x80 plus the length of the string followed by the * string. The range of the first byte is thus [0x80, 0xb7]. */ private static final int OFFSET_SHORT_ITEM = 0x80; /** * [0xb7] * If a string is more than 55 bytes long, the RLP encoding consists of a * single byte with value 0xb7 plus the length of the length of the string * in binary form, followed by the length of the string, followed by the * string. For example, a length-1024 string would be encoded as * \xb9\x04\x00 followed by the string. The range of the first byte is thus * [0xb8, 0xbf]. */ private static final int OFFSET_LONG_ITEM = 0xb7; /** * [0xc0] * If the total payload of a list (i.e. the combined length of all its * items) is 0-55 bytes long, the RLP encoding consists of a single byte * with value 0xc0 plus the length of the list followed by the concatenation * of the RLP encodings of the items. The range of the first byte is thus * [0xc0, 0xf7]. */ private static final int OFFSET_SHORT_LIST = 0xc0; /** * [0xf7] * If the total payload of a list is more than 55 bytes long, the RLP * encoding consists of a single byte with value 0xf7 plus the length of the * length of the list in binary form, followed by the length of the list, * followed by the concatenation of the RLP encodings of the items. The * range of the first byte is thus [0xf8, 0xff]. */ private static final int OFFSET_LONG_LIST = 0xf7; /* ****************************************************** * DECODING * * ******************************************************/ private static byte decodeOneByteItem(byte[] data, int index) { // null item if ((data[index] & 0xFF) == OFFSET_SHORT_ITEM) { return (byte) (data[index] - OFFSET_SHORT_ITEM); } // single byte item if ((data[index] & 0xFF) < OFFSET_SHORT_ITEM) { return data[index]; } // single byte item if ((data[index] & 0xFF) == OFFSET_SHORT_ITEM + 1) { return data[index + 1]; } return 0; } public static int decodeInt(byte[] data, int index) { int value = 0; // NOTE: From RLP doc: // Ethereum integers must be represented in big endian binary form // with no leading zeroes (thus making the integer value zero be // equivalent to the empty byte array) if (data[index] == 0x00) { throw new RuntimeException("not a number"); } else if ((data[index] & 0xFF) < OFFSET_SHORT_ITEM) { return data[index]; } else if ((data[index] & 0xFF) <= OFFSET_SHORT_ITEM + Integer.BYTES) { byte length = (byte) (data[index] - OFFSET_SHORT_ITEM); byte pow = (byte) (length - 1); for (int i = 1; i <= length; ++i) { // << (8 * pow) == bit shift to 0 (*1), 8 (*256) , 16 (*65..).. value += (data[index + i] & 0xFF) << (8 * pow); pow--; } } else { // If there are more than 4 bytes, it is not going // to decode properly into an int. throw new RuntimeException("wrong decode attempt"); } return value; } static short decodeShort(byte[] data, int index) { short value = 0; if (data[index] == 0x00) { throw new RuntimeException("not a number"); } else if ((data[index] & 0xFF) < OFFSET_SHORT_ITEM) { return data[index]; } else if ((data[index] & 0xFF) <= OFFSET_SHORT_ITEM + Short.BYTES) { byte length = (byte) (data[index] - OFFSET_SHORT_ITEM); byte pow = (byte) (length - 1); for (int i = 1; i <= length; ++i) { // << (8 * pow) == bit shift to 0 (*1), 8 (*256) , 16 (*65..) value += (data[index + i] & 0xFF) << (8 * pow); pow--; } } else { // If there are more than 2 bytes, it is not going // to decode properly into a short. throw new RuntimeException("wrong decode attempt"); } return value; } public static long decodeLong(byte[] data, int index) { long value = 0; if (data[index] == 0x00) { throw new RuntimeException("not a number"); } else if ((data[index] & 0xFF) < OFFSET_SHORT_ITEM) { return data[index]; } else if ((data[index] & 0xFF) <= OFFSET_SHORT_ITEM + Long.BYTES) { byte length = (byte) (data[index] - OFFSET_SHORT_ITEM); byte pow = (byte) (length - 1); for (int i = 1; i <= length; ++i) { // << (8 * pow) == bit shift to 0 (*1), 8 (*256) , 16 (*65..).. value += (long) (data[index + i] & 0xFF) << (8 * pow); pow--; } } else { // If there are more than 8 bytes, it is not going // to decode properly into a long. throw new RuntimeException("wrong decode attempt"); } return value; } private static String decodeStringItem(byte[] data, int index) { final byte[] valueBytes = decodeItemBytes(data, index); if (valueBytes.length == 0) { // shortcut return ""; } else { return new String(valueBytes); } } public static BigInteger decodeBigInteger(byte[] data, int index) { final byte[] valueBytes = decodeItemBytes(data, index); if (valueBytes.length == 0) { // shortcut return BigInteger.ZERO; } else { BigInteger res = new BigInteger(1, valueBytes); return res; } } private static byte[] decodeByteArray(byte[] data, int index) { return decodeItemBytes(data, index); } private static int nextItemLength(byte[] data, int index) { if (index >= data.length) return -1; // [0xf8, 0xff] if ((data[index] & 0xFF) > OFFSET_LONG_LIST) { byte lengthOfLength = (byte) (data[index] - OFFSET_LONG_LIST); return calcLength(lengthOfLength, data, index); } // [0xc0, 0xf7] if ((data[index] & 0xFF) >= OFFSET_SHORT_LIST && (data[index] & 0xFF) <= OFFSET_LONG_LIST) { return (byte) ((data[index] & 0xFF) - OFFSET_SHORT_LIST); } // [0xb8, 0xbf] if ((data[index] & 0xFF) > OFFSET_LONG_ITEM && (data[index] & 0xFF) < OFFSET_SHORT_LIST) { byte lengthOfLength = (byte) (data[index] - OFFSET_LONG_ITEM); return calcLength(lengthOfLength, data, index); } // [0x81, 0xb7] if ((data[index] & 0xFF) > OFFSET_SHORT_ITEM && (data[index] & 0xFF) <= OFFSET_LONG_ITEM) { return (byte) ((data[index] & 0xFF) - OFFSET_SHORT_ITEM); } // [0x00, 0x80] if ((data[index] & 0xFF) <= OFFSET_SHORT_ITEM) { return 1; } return -1; } public static byte[] decodeIP4Bytes(byte[] data, int index) { int offset = 1; final byte[] result = new byte[4]; for (int i = 0; i < 4; i++) { result[i] = decodeOneByteItem(data, index + offset); if ((data[index + offset] & 0xFF) > OFFSET_SHORT_ITEM) offset += 2; else offset += 1; } // return IP address return result; } public static int getFirstListElement(byte[] payload, int pos) { if (pos >= payload.length) return -1; // [0xf8, 0xff] if ((payload[pos] & 0xFF) > OFFSET_LONG_LIST) { byte lengthOfLength = (byte) (payload[pos] - OFFSET_LONG_LIST); return pos + lengthOfLength + 1; } // [0xc0, 0xf7] if ((payload[pos] & 0xFF) >= OFFSET_SHORT_LIST && (payload[pos] & 0xFF) <= OFFSET_LONG_LIST) { return pos + 1; } // [0xb8, 0xbf] if ((payload[pos] & 0xFF) > OFFSET_LONG_ITEM && (payload[pos] & 0xFF) < OFFSET_SHORT_LIST) { byte lengthOfLength = (byte) (payload[pos] - OFFSET_LONG_ITEM); return pos + lengthOfLength + 1; } return -1; } public static int getNextElementIndex(byte[] payload, int pos) { if (pos >= payload.length) return -1; // [0xf8, 0xff] if ((payload[pos] & 0xFF) > OFFSET_LONG_LIST) { byte lengthOfLength = (byte) (payload[pos] - OFFSET_LONG_LIST); int length = calcLength(lengthOfLength, payload, pos); return pos + lengthOfLength + length + 1; } // [0xc0, 0xf7] if ((payload[pos] & 0xFF) >= OFFSET_SHORT_LIST && (payload[pos] & 0xFF) <= OFFSET_LONG_LIST) { byte length = (byte) ((payload[pos] & 0xFF) - OFFSET_SHORT_LIST); return pos + 1 + length; } // [0xb8, 0xbf] if ((payload[pos] & 0xFF) > OFFSET_LONG_ITEM && (payload[pos] & 0xFF) < OFFSET_SHORT_LIST) { byte lengthOfLength = (byte) (payload[pos] - OFFSET_LONG_ITEM); int length = calcLength(lengthOfLength, payload, pos); return pos + lengthOfLength + length + 1; } // [0x81, 0xb7] if ((payload[pos] & 0xFF) > OFFSET_SHORT_ITEM && (payload[pos] & 0xFF) <= OFFSET_LONG_ITEM) { byte length = (byte) ((payload[pos] & 0xFF) - OFFSET_SHORT_ITEM); return pos + 1 + length; } // []0x80] if ((payload[pos] & 0xFF) == OFFSET_SHORT_ITEM) { return pos + 1; } // [0x00, 0x7f] if ((payload[pos] & 0xFF) < OFFSET_SHORT_ITEM) { return pos + 1; } return -1; } /** * Get exactly one message payload */ public static void fullTraverse(byte[] msgData, int level, int startPos, int endPos, int levelToIndex, Queue index) { try { if (msgData == null || msgData.length == 0) return; int pos = startPos; while (pos < endPos) { if (level == levelToIndex) index.add(pos); // It's a list with a payload more than 55 bytes // data[0] - 0xF7 = how many next bytes allocated // for the length of the list // [0xf8, 0xff] if ((msgData[pos] & 0xFF) > OFFSET_LONG_LIST) { byte lengthOfLength = (byte) (msgData[pos] - OFFSET_LONG_LIST); int length = calcLength(lengthOfLength, msgData, pos); // now we can parse an item for data[1]..data[length] System.out.println("-- level: [" + level + "] Found big list length: " + length); fullTraverse(msgData, level + 1, pos + lengthOfLength + 1, pos + lengthOfLength + length, levelToIndex, index); pos += lengthOfLength + length + 1; continue; } // It's a list with a payload less than or equal to 55 bytes // [0xc0, 0xf7] if ((msgData[pos] & 0xFF) >= OFFSET_SHORT_LIST && (msgData[pos] & 0xFF) <= OFFSET_LONG_LIST) { byte length = (byte) ((msgData[pos] & 0xFF) - OFFSET_SHORT_LIST); System.out.println("-- level: [" + level + "] Found small list length: " + length); fullTraverse(msgData, level + 1, pos + 1, pos + length + 1, levelToIndex, index); pos += 1 + length; continue; } // It's an item with a payload more than 55 bytes // data[0] - 0xB7 = how much next bytes allocated for // the length of the string // [0xb8, 0xbf] if ((msgData[pos] & 0xFF) > OFFSET_LONG_ITEM && (msgData[pos] & 0xFF) < OFFSET_SHORT_LIST) { byte lengthOfLength = (byte) (msgData[pos] - OFFSET_LONG_ITEM); int length = calcLength(lengthOfLength, msgData, pos); // now we can parse an item for data[1]..data[length] System.out.println("-- level: [" + level + "] Found big item length: " + length); pos += lengthOfLength + length + 1; continue; } // It's an item less than 55 bytes long, // data[0] - 0x80 == length of the item // [0x81, 0xb7] if ((msgData[pos] & 0xFF) > OFFSET_SHORT_ITEM && (msgData[pos] & 0xFF) <= OFFSET_LONG_ITEM) { byte length = (byte) ((msgData[pos] & 0xFF) - OFFSET_SHORT_ITEM); System.out.println("-- level: [" + level + "] Found small item length: " + length); pos += 1 + length; continue; } // null item // [0x80] if ((msgData[pos] & 0xFF) == OFFSET_SHORT_ITEM) { System.out.println("-- level: [" + level + "] Found null item: "); pos += 1; continue; } // single byte item // [0x00, 0x7f] if ((msgData[pos] & 0xFF) < OFFSET_SHORT_ITEM) { System.out.println("-- level: [" + level + "] Found single item: "); pos += 1; continue; } } } catch (Throwable th) { throw new RuntimeException("RLP wrong encoding", th.fillInStackTrace()); } } /** * Parse length of long item or list. * RLP supports lengths with up to 8 bytes long, * but due to java limitation it returns either encoded length * or {@link Integer#MAX_VALUE} in case if encoded length is greater * * @param lengthOfLength length of length in bytes * @param msgData message * @param pos position to parse from * @return calculated length */ private static int calcLength(int lengthOfLength, byte[] msgData, int pos) { byte pow = (byte) (lengthOfLength - 1); int length = 0; for (int i = 1; i <= lengthOfLength; ++i) { int bt = msgData[pos + i] & 0xFF; int shift = 8 * pow; // no leading zeros are acceptable if (bt == 0 && length == 0) { throw new RuntimeException("RLP length contains leading zeros"); } // return MAX_VALUE if index of highest bit is more than 31 if (32 - Integer.numberOfLeadingZeros(bt) + shift > 31) { return Integer.MAX_VALUE; } length += bt << shift; pow--; } return length; } public static byte getCommandCode(byte[] data) { int index = getFirstListElement(data, 0); final byte command = data[index]; return ((command & 0xFF) == OFFSET_SHORT_ITEM) ? 0 : command; } /** * Parse wire byte[] message into RLP elements * * @param msgData - raw RLP data * @return rlpList * - outcome of recursive RLP structure */ public static RLPList decode2(byte[] msgData) { RLPList rlpList = new RLPList(); fullTraverse(msgData, 0, 0, msgData.length, 1, rlpList); return rlpList; } public static RLPElement decode2OneItem(byte[] msgData, int startPos) { RLPList rlpList = new RLPList(); fullTraverse(msgData, 0, startPos, startPos + 1, 1, rlpList); return rlpList.get(0); } /** * Get exactly one message payload */ private static void fullTraverse(byte[] msgData, int level, int startPos, int endPos, int levelToIndex, RLPList rlpList) { try { if (msgData == null || msgData.length == 0) return; int pos = startPos; while (pos < endPos) { // logger.debug("fullTraverse: level: " + level + " startPos: " + pos + " endPos: " + endPos); // It's a list with a payload more than 55 bytes // data[0] - 0xF7 = how many next bytes allocated // for the length of the list if ((msgData[pos] & 0xFF) > OFFSET_LONG_LIST) { byte lengthOfLength = (byte) (msgData[pos] - OFFSET_LONG_LIST); int length = calcLength(lengthOfLength, msgData, pos); if (length < SIZE_THRESHOLD) { throw new RuntimeException("Short list has been encoded as long list"); } // check payload bounds if (length > msgData.length - pos - lengthOfLength) { throw new RuntimeException("Parsed data lays outside of RLP length boundaries"); } byte[] rlpData = new byte[lengthOfLength + length + 1]; System.arraycopy(msgData, pos, rlpData, 0, lengthOfLength + length + 1); RLPList newLevelList = new RLPList(); newLevelList.setRLPData(rlpData); fullTraverse(msgData, level + 1, pos + lengthOfLength + 1, pos + lengthOfLength + length + 1, levelToIndex, newLevelList); rlpList.add(newLevelList); pos += lengthOfLength + length + 1; continue; } // It's a list with a payload less than 55 bytes if ((msgData[pos] & 0xFF) >= OFFSET_SHORT_LIST && (msgData[pos] & 0xFF) <= OFFSET_LONG_LIST) { byte length = (byte) ((msgData[pos] & 0xFF) - OFFSET_SHORT_LIST); byte[] rlpData = new byte[length + 1]; System.arraycopy(msgData, pos, rlpData, 0, length + 1); RLPList newLevelList = new RLPList(); newLevelList.setRLPData(rlpData); if (length > 0) fullTraverse(msgData, level + 1, pos + 1, pos + length + 1, levelToIndex, newLevelList); rlpList.add(newLevelList); pos += 1 + length; continue; } // It's an item with a payload more than 55 bytes // data[0] - 0xB7 = how much next bytes allocated for // the length of the string if ((msgData[pos] & 0xFF) > OFFSET_LONG_ITEM && (msgData[pos] & 0xFF) < OFFSET_SHORT_LIST) { byte lengthOfLength = (byte) (msgData[pos] - OFFSET_LONG_ITEM); int length = calcLength(lengthOfLength, msgData, pos); if (length < SIZE_THRESHOLD) { throw new RuntimeException("Short item has been encoded as long item"); } // check payload bounds if (length > msgData.length - pos - lengthOfLength) { throw new RuntimeException("Parsed data lays outside of RLP length boundaries"); } // now we can parse an item for data[1]..data[length] byte[] item = new byte[length]; System.arraycopy(msgData, pos + lengthOfLength + 1, item, 0, length); RLPItem rlpItem = new RLPItem(item); rlpList.add(rlpItem); pos += lengthOfLength + length + 1; continue; } // It's an item less than 55 bytes long, // data[0] - 0x80 == length of the item if ((msgData[pos] & 0xFF) > OFFSET_SHORT_ITEM && (msgData[pos] & 0xFF) <= OFFSET_LONG_ITEM) { byte length = (byte) ((msgData[pos] & 0xFF) - OFFSET_SHORT_ITEM); byte[] item = new byte[length]; System.arraycopy(msgData, pos + 1, item, 0, length); if (length == 1 && (item[0] & 0xFF) < OFFSET_SHORT_ITEM) { throw new RuntimeException("Single byte has been encoded as byte string"); } RLPItem rlpItem = new RLPItem(item); rlpList.add(rlpItem); pos += 1 + length; continue; } // null item if ((msgData[pos] & 0xFF) == OFFSET_SHORT_ITEM) { byte[] item = ByteUtil.EMPTY_BYTE_ARRAY; RLPItem rlpItem = new RLPItem(item); rlpList.add(rlpItem); pos += 1; continue; } // single byte item if ((msgData[pos] & 0xFF) < OFFSET_SHORT_ITEM) { byte[] item = {(byte) (msgData[pos] & 0xFF)}; RLPItem rlpItem = new RLPItem(item); rlpList.add(rlpItem); pos += 1; } } } catch (Exception e) { throw new RuntimeException("RLP wrong encoding (" + Hex.toHexString(msgData, startPos, endPos - startPos) + ")", e); } catch (OutOfMemoryError e) { throw new RuntimeException("Invalid RLP (excessive mem allocation while parsing) (" + Hex.toHexString(msgData, startPos, endPos - startPos) + ")", e); } } /** * Reads any RLP encoded byte-array and returns all objects as byte-array or list of byte-arrays * * @param data RLP encoded byte-array * @param pos position in the array to start reading * @return DecodeResult encapsulates the decoded items as a single Object and the final read position */ public static DecodeResult decode(byte[] data, int pos) { if (data == null || data.length < 1) { return null; } int prefix = data[pos] & 0xFF; if (prefix == OFFSET_SHORT_ITEM) { // 0x80 return new DecodeResult(pos + 1, ""); // means no length or 0 } else if (prefix < OFFSET_SHORT_ITEM) { // [0x00, 0x7f] return new DecodeResult(pos + 1, new byte[]{data[pos]}); // byte is its own RLP encoding } else if (prefix <= OFFSET_LONG_ITEM) { // [0x81, 0xb7] int len = prefix - OFFSET_SHORT_ITEM; // length of the encoded bytes return new DecodeResult(pos + 1 + len, copyOfRange(data, pos + 1, pos + 1 + len)); } else if (prefix < OFFSET_SHORT_LIST) { // [0xb8, 0xbf] int lenlen = prefix - OFFSET_LONG_ITEM; // length of length the encoded bytes int lenbytes = byteArrayToInt(copyOfRange(data, pos + 1, pos + 1 + lenlen)); // length of encoded bytes return new DecodeResult(pos + 1 + lenlen + lenbytes, copyOfRange(data, pos + 1 + lenlen, pos + 1 + lenlen + lenbytes)); } else if (prefix <= OFFSET_LONG_LIST) { // [0xc0, 0xf7] int len = prefix - OFFSET_SHORT_LIST; // length of the encoded list int prevPos = pos; pos++; return decodeList(data, pos, prevPos, len); } else if (prefix <= 0xFF) { // [0xf8, 0xff] int lenlen = prefix - OFFSET_LONG_LIST; // length of length the encoded list int lenlist = byteArrayToInt(copyOfRange(data, pos + 1, pos + 1 + lenlen)); // length of encoded bytes pos = pos + lenlen + 1; // start at position of first element in list int prevPos = lenlist; return decodeList(data, pos, prevPos, lenlist); } else { throw new RuntimeException("Only byte values between 0x00 and 0xFF are supported, but got: " + prefix); } } public static final class LList { private final byte[] rlp; private final int[] offsets = new int[32]; private final int[] lens = new int[32]; private int cnt; public LList(byte[] rlp) { this.rlp = rlp; } public byte[] getEncoded() { byte encoded[][] = new byte[cnt][]; for (int i = 0; i < cnt; i++) { encoded[i] = encodeElement(getBytes(i)); } return encodeList(encoded); } public void add(int off, int len, boolean isList) { offsets[cnt] = off; lens[cnt] = isList ? (-1 - len) : len; cnt++; } public byte[] getBytes(int idx) { int len = lens[idx]; len = len < 0 ? (-len - 1) : len; byte[] ret = new byte[len]; System.arraycopy(rlp, offsets[idx], ret, 0, len); return ret; } public LList getList(int idx) { return decodeLazyList(rlp, offsets[idx], -lens[idx] - 1); } public boolean isList(int idx) { return lens[idx] < 0; } public int size() { return cnt; } } public static LList decodeLazyList(byte[] data) { return decodeLazyList(data, 0, data.length).getList(0); } public static LList decodeLazyList(byte[] data, int pos, int length) { if (data == null || data.length < 1) { return null; } LList ret = new LList(data); int end = pos + length; while (pos < end) { int prefix = data[pos] & 0xFF; if (prefix == OFFSET_SHORT_ITEM) { // 0x80 ret.add(pos, 0, false); // means no length or 0 pos++; } else if (prefix < OFFSET_SHORT_ITEM) { // [0x00, 0x7f] ret.add(pos, 1, false); // means no length or 0 pos++; } else if (prefix <= OFFSET_LONG_ITEM) { // [0x81, 0xb7] int len = prefix - OFFSET_SHORT_ITEM; // length of the encoded bytes ret.add(pos + 1, len, false); pos += len + 1; } else if (prefix < OFFSET_SHORT_LIST) { // [0xb8, 0xbf] int lenlen = prefix - OFFSET_LONG_ITEM; // length of length the encoded bytes int lenbytes = byteArrayToInt(copyOfRange(data, pos + 1, pos + 1 + lenlen)); // length of encoded bytes ret.add(pos + 1 + lenlen, lenbytes, false); pos += 1 + lenlen + lenbytes; } else if (prefix <= OFFSET_LONG_LIST) { // [0xc0, 0xf7] int len = prefix - OFFSET_SHORT_LIST; // length of the encoded list ret.add(pos + 1, len, true); pos += 1 + len; } else if (prefix <= 0xFF) { // [0xf8, 0xff] int lenlen = prefix - OFFSET_LONG_LIST; // length of length the encoded list int lenlist = byteArrayToInt(copyOfRange(data, pos + 1, pos + 1 + lenlen)); // length of encoded bytes ret.add(pos + 1 + lenlen, lenlist, true); pos += 1 + lenlen + lenlist; // start at position of first element in list } else { throw new RuntimeException("Only byte values between 0x00 and 0xFF are supported, but got: " + prefix); } } return ret; } private static DecodeResult decodeList(byte[] data, int pos, int prevPos, int len) { List slice = new ArrayList<>(); for (int i = 0; i < len; ) { // Get the next item in the data list and append it DecodeResult result = decode(data, pos); slice.add(result.getDecoded()); // Increment pos by the amount bytes in the previous read prevPos = result.getPos(); i += (prevPos - pos); pos = prevPos; } return new DecodeResult(pos, slice.toArray()); } /* ****************************************************** * ENCODING * * ******************************************************/ /** * Turn Object into its RLP encoded equivalent of a byte-array * Support for String, Integer, BigInteger and Lists of any of these types. * * @param input as object or List of objects * @return byte[] RLP encoded */ public static byte[] encode(Object input) { Value val = new Value(input); if (val.isList()) { List inputArray = val.asList(); if (inputArray.isEmpty()) { return encodeLength(inputArray.size(), OFFSET_SHORT_LIST); } byte[] output = ByteUtil.EMPTY_BYTE_ARRAY; for (Object object : inputArray) { output = concatenate(output, encode(object)); } byte[] prefix = encodeLength(output.length, OFFSET_SHORT_LIST); return concatenate(prefix, output); } else { byte[] inputAsBytes = toBytes(input); if (inputAsBytes.length == 1 && (inputAsBytes[0] & 0xff) <= 0x80) { return inputAsBytes; } else { byte[] firstByte = encodeLength(inputAsBytes.length, OFFSET_SHORT_ITEM); return concatenate(firstByte, inputAsBytes); } } } /** * Integer limitation goes up to 2^31-1 so length can never be bigger than MAX_ITEM_LENGTH */ public static byte[] encodeLength(int length, int offset) { if (length < SIZE_THRESHOLD) { byte firstByte = (byte) (length + offset); return new byte[]{firstByte}; } else if (length < MAX_ITEM_LENGTH) { byte[] binaryLength; if (length > 0xFF) binaryLength = intToBytesNoLeadZeroes(length); else binaryLength = new byte[]{(byte) length}; byte firstByte = (byte) (binaryLength.length + offset + SIZE_THRESHOLD - 1); return concatenate(new byte[]{firstByte}, binaryLength); } else { throw new RuntimeException("Input too long"); } } public static byte[] encodeByte(byte singleByte) { if ((singleByte & 0xFF) == 0) { return new byte[]{(byte) OFFSET_SHORT_ITEM}; } else if ((singleByte & 0xFF) <= 0x7F) { return new byte[]{singleByte}; } else { return new byte[]{(byte) (OFFSET_SHORT_ITEM + 1), singleByte}; } } public static byte[] encodeShort(short singleShort) { if ((singleShort & 0xFF) == singleShort) return encodeByte((byte) singleShort); else { return new byte[]{(byte) (OFFSET_SHORT_ITEM + 2), (byte) (singleShort >> 8 & 0xFF), (byte) (singleShort >> 0 & 0xFF)}; } } public static byte[] encodeInt(int singleInt) { if ((singleInt & 0xFF) == singleInt) return encodeByte((byte) singleInt); else if ((singleInt & 0xFFFF) == singleInt) return encodeShort((short) singleInt); else if ((singleInt & 0xFFFFFF) == singleInt) return new byte[]{(byte) (OFFSET_SHORT_ITEM + 3), (byte) (singleInt >>> 16), (byte) (singleInt >>> 8), (byte) singleInt}; else { return new byte[]{(byte) (OFFSET_SHORT_ITEM + 4), (byte) (singleInt >>> 24), (byte) (singleInt >>> 16), (byte) (singleInt >>> 8), (byte) singleInt}; } } public static byte[] encodeString(String srcString) { return encodeElement(srcString.getBytes()); } public static byte[] encodeBigInteger(BigInteger srcBigInteger) { if (srcBigInteger.compareTo(BigInteger.ZERO) < 0) throw new RuntimeException("negative numbers are not allowed"); if (srcBigInteger.equals(BigInteger.ZERO)) return encodeByte((byte) 0); else return encodeElement(asUnsignedByteArray(srcBigInteger)); } public static byte[] encodeElement(byte[] srcData) { // [0x80] if (isNullOrZeroArray(srcData)) { return new byte[]{(byte) OFFSET_SHORT_ITEM}; // [0x00] } else if (isSingleZero(srcData)) { return srcData; // [0x01, 0x7f] - single byte, that byte is its own RLP encoding } else if (srcData.length == 1 && (srcData[0] & 0xFF) < 0x80) { return srcData; // [0x80, 0xb7], 0 - 55 bytes } else if (srcData.length < SIZE_THRESHOLD) { // length = 8X byte length = (byte) (OFFSET_SHORT_ITEM + srcData.length); byte[] data = Arrays.copyOf(srcData, srcData.length + 1); System.arraycopy(data, 0, data, 1, srcData.length); data[0] = length; return data; // [0xb8, 0xbf], 56+ bytes } else { // length of length = BX // prefix = [BX, [length]] int tmpLength = srcData.length; byte lengthOfLength = 0; while (tmpLength != 0) { ++lengthOfLength; tmpLength = tmpLength >> 8; } // set length Of length at first byte byte[] data = new byte[1 + lengthOfLength + srcData.length]; data[0] = (byte) (OFFSET_LONG_ITEM + lengthOfLength); // copy length after first byte tmpLength = srcData.length; for (int i = lengthOfLength; i > 0; --i) { data[i] = (byte) (tmpLength & 0xFF); tmpLength = tmpLength >> 8; } // at last copy the number bytes after its length System.arraycopy(srcData, 0, data, 1 + lengthOfLength, srcData.length); return data; } } public static int calcElementPrefixSize(byte[] srcData) { if (isNullOrZeroArray(srcData)) return 0; else if (isSingleZero(srcData)) return 0; else if (srcData.length == 1 && (srcData[0] & 0xFF) < 0x80) { return 0; } else if (srcData.length < SIZE_THRESHOLD) { return 1; } else { // length of length = BX // prefix = [BX, [length]] int tmpLength = srcData.length; byte byteNum = 0; while (tmpLength != 0) { ++byteNum; tmpLength = tmpLength >> 8; } return 1 + byteNum; } } public static byte[] encodeListHeader(int size) { if (size == 0) { return new byte[]{(byte) OFFSET_SHORT_LIST}; } int totalLength = size; byte[] header; if (totalLength < SIZE_THRESHOLD) { header = new byte[1]; header[0] = (byte) (OFFSET_SHORT_LIST + totalLength); } else { // length of length = BX // prefix = [BX, [length]] int tmpLength = totalLength; byte byteNum = 0; while (tmpLength != 0) { ++byteNum; tmpLength = tmpLength >> 8; } tmpLength = totalLength; byte[] lenBytes = new byte[byteNum]; for (int i = 0; i < byteNum; ++i) { lenBytes[byteNum - 1 - i] = (byte) ((tmpLength >> (8 * i)) & 0xFF); } // first byte = F7 + bytes.length header = new byte[1 + lenBytes.length]; header[0] = (byte) (OFFSET_LONG_LIST + byteNum); System.arraycopy(lenBytes, 0, header, 1, lenBytes.length); } return header; } public static byte[] encodeLongElementHeader(int length) { if (length < SIZE_THRESHOLD) { if (length == 0) return new byte[]{(byte) 0x80}; else return new byte[]{(byte) (0x80 + length)}; } else { // length of length = BX // prefix = [BX, [length]] int tmpLength = length; byte byteNum = 0; while (tmpLength != 0) { ++byteNum; tmpLength = tmpLength >> 8; } byte[] lenBytes = new byte[byteNum]; for (int i = 0; i < byteNum; ++i) { lenBytes[byteNum - 1 - i] = (byte) ((length >> (8 * i)) & 0xFF); } // first byte = F7 + bytes.length byte[] header = new byte[1 + lenBytes.length]; header[0] = (byte) (OFFSET_LONG_ITEM + byteNum); System.arraycopy(lenBytes, 0, header, 1, lenBytes.length); return header; } } public static byte[] encodeSet(Set data) { int dataLength = 0; Set encodedElements = new HashSet<>(); for (ByteArrayWrapper element : data) { byte[] encodedElement = RLP.encodeElement(element.getData()); dataLength += encodedElement.length; encodedElements.add(encodedElement); } byte[] listHeader = encodeListHeader(dataLength); byte[] output = new byte[listHeader.length + dataLength]; System.arraycopy(listHeader, 0, output, 0, listHeader.length); int cummStart = listHeader.length; for (byte[] element : encodedElements) { System.arraycopy(element, 0, output, cummStart, element.length); cummStart += element.length; } return output; } public static byte[] encodeList(byte[]... elements) { if (elements == null) { return new byte[]{(byte) OFFSET_SHORT_LIST}; } int totalLength = 0; for (byte[] element1 : elements) { totalLength += element1.length; } byte[] data; int copyPos; if (totalLength < SIZE_THRESHOLD) { data = new byte[1 + totalLength]; data[0] = (byte) (OFFSET_SHORT_LIST + totalLength); copyPos = 1; } else { // length of length = BX // prefix = [BX, [length]] int tmpLength = totalLength; byte byteNum = 0; while (tmpLength != 0) { ++byteNum; tmpLength = tmpLength >> 8; } tmpLength = totalLength; byte[] lenBytes = new byte[byteNum]; for (int i = 0; i < byteNum; ++i) { lenBytes[byteNum - 1 - i] = (byte) ((tmpLength >> (8 * i)) & 0xFF); } // first byte = F7 + bytes.length data = new byte[1 + lenBytes.length + totalLength]; data[0] = (byte) (OFFSET_LONG_LIST + byteNum); System.arraycopy(lenBytes, 0, data, 1, lenBytes.length); copyPos = lenBytes.length + 1; } for (byte[] element : elements) { System.arraycopy(element, 0, data, copyPos, element.length); copyPos += element.length; } return data; } /* * Utility function to convert Objects into byte arrays */ private static byte[] toBytes(Object input) { if (input instanceof byte[]) { return (byte[]) input; } else if (input instanceof String) { String inputString = (String) input; return inputString.getBytes(); } else if (input instanceof Long) { Long inputLong = (Long) input; return (inputLong == 0) ? ByteUtil.EMPTY_BYTE_ARRAY : asUnsignedByteArray(BigInteger.valueOf(inputLong)); } else if (input instanceof Integer) { Integer inputInt = (Integer) input; return (inputInt == 0) ? ByteUtil.EMPTY_BYTE_ARRAY : asUnsignedByteArray(BigInteger.valueOf(inputInt)); } else if (input instanceof BigInteger) { BigInteger inputBigInt = (BigInteger) input; return (inputBigInt.equals(BigInteger.ZERO)) ? ByteUtil.EMPTY_BYTE_ARRAY : asUnsignedByteArray(inputBigInt); } else if (input instanceof Value) { Value val = (Value) input; return toBytes(val.asObj()); } throw new RuntimeException("Unsupported type: Only accepting String, Integer and BigInteger for now"); } private static byte[] decodeItemBytes(byte[] data, int index) { final int length = calculateItemLength(data, index); // [0x80] if (length == 0) { return new byte[0]; // [0x00, 0x7f] - single byte with item } else if ((data[index] & 0xFF) < OFFSET_SHORT_ITEM) { byte[] valueBytes = new byte[1]; System.arraycopy(data, index, valueBytes, 0, 1); return valueBytes; // [0x01, 0xb7] - 1-55 bytes item } else if ((data[index] & 0xFF) <= OFFSET_LONG_ITEM) { byte[] valueBytes = new byte[length]; System.arraycopy(data, index + 1, valueBytes, 0, length); return valueBytes; // [0xb8, 0xbf] - 56+ bytes item } else if ((data[index] & 0xFF) > OFFSET_LONG_ITEM && (data[index] & 0xFF) < OFFSET_SHORT_LIST) { byte lengthOfLength = (byte) (data[index] - OFFSET_LONG_ITEM); byte[] valueBytes = new byte[length]; System.arraycopy(data, index + 1 + lengthOfLength, valueBytes, 0, length); return valueBytes; } else { throw new RuntimeException("wrong decode attempt"); } } private static int calculateItemLength(byte[] data, int index) { // [0xb8, 0xbf] - 56+ bytes item if ((data[index] & 0xFF) > OFFSET_LONG_ITEM && (data[index] & 0xFF) < OFFSET_SHORT_LIST) { byte lengthOfLength = (byte) (data[index] - OFFSET_LONG_ITEM); return calcLength(lengthOfLength, data, index); // [0x81, 0xb7] - 0-55 bytes item } else if ((data[index] & 0xFF) > OFFSET_SHORT_ITEM && (data[index] & 0xFF) <= OFFSET_LONG_ITEM) { return (byte) (data[index] - OFFSET_SHORT_ITEM); // [0x80] - item = 0 itself } else if ((data[index] & 0xFF) == OFFSET_SHORT_ITEM) { return (byte) 0; // [0x00, 0x7f] - 1 byte item, no separate length representation } else if ((data[index] & 0xFF) < OFFSET_SHORT_ITEM) { return (byte) 1; } else { throw new RuntimeException("wrong decode attempt"); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/rlp/RLPElement.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.rlp; import java.io.Serializable; /** * Wrapper class for decoded elements from an RLP encoded byte array. * * @author Roman Mandeleil * @since 01.04.2014 */ public interface RLPElement extends Serializable { byte[] getRLPData(); } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/rlp/RLPItem.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.rlp; /** * @author Roman Mandeleil * @since 21.04.14 */ public class RLPItem implements RLPElement { private final byte[] rlpData; public RLPItem(byte[] rlpData) { this.rlpData = rlpData; } public byte[] getRLPData() { if (rlpData.length == 0) return null; return rlpData; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/rlp/RLPList.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.rlp; import com.quincysx.crypto.ethereum.utils.ByteUtil; import java.util.ArrayList; /** * @author Roman Mandeleil * @since 21.04.14 */ public class RLPList extends ArrayList implements RLPElement { byte[] rlpData; public void setRLPData(byte[] rlpData) { this.rlpData = rlpData; } public byte[] getRLPData() { return rlpData; } public static void recursivePrint(RLPElement element) { if (element == null) throw new RuntimeException("RLPElement object can't be null"); if (element instanceof RLPList) { RLPList rlpList = (RLPList) element; System.out.print("["); for (RLPElement singleElement : rlpList) recursivePrint(singleElement); System.out.print("]"); } else { String hex = ByteUtil.toHexString(element.getRLPData()); System.out.print(hex + ", "); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/rlp/Value.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.rlp; import com.cedarsoftware.util.DeepEquals; import com.quincysx.crypto.ethereum.utils.ByteUtil; //import org.ethereum.crypto.HashUtil; import org.spongycastle.util.encoders.Hex; import java.math.BigInteger; import java.util.Arrays; import java.util.List; /** * Class to encapsulate an object and provide utilities for conversion */ public class Value { private Object value; private byte[] rlp; private byte[] sha3; private boolean decoded = false; public static Value fromRlpEncoded(byte[] data) { if (data != null && data.length != 0) { Value v = new Value(); v.init(data); return v; } return null; } public Value() { } public void init(byte[] rlp) { this.rlp = rlp; } public Value(Object obj) { this.decoded = true; if (obj == null) return; if (obj instanceof Value) { this.value = ((Value) obj).asObj(); } else { this.value = obj; } } public Value withHash(byte[] hash) { sha3 = hash; return this; } /* ***************** * Convert * *****************/ public Object asObj() { decode(); return value; } public List asList() { decode(); Object[] valueArray = (Object[]) value; return Arrays.asList(valueArray); } public int asInt() { decode(); if (isInt()) { return (Integer) value; } else if (isBytes()) { return new BigInteger(1, asBytes()).intValue(); } return 0; } public long asLong() { decode(); if (isLong()) { return (Long) value; } else if (isBytes()) { return new BigInteger(1, asBytes()).longValue(); } return 0; } public BigInteger asBigInt() { decode(); return (BigInteger) value; } public String asString() { decode(); if (isBytes()) { return new String((byte[]) value); } else if (isString()) { return (String) value; } return ""; } public byte[] asBytes() { decode(); if (isBytes()) { return (byte[]) value; } else if (isString()) { return asString().getBytes(); } return ByteUtil.EMPTY_BYTE_ARRAY; } public String getHex() { return Hex.toHexString(this.encode()); } public byte[] getData() { return this.encode(); } public int[] asSlice() { return (int[]) value; } public Value get(int index) { if (isList()) { // Guard for OutOfBounds if (asList().size() <= index) { return new Value(null); } if (index < 0) { throw new RuntimeException("Negative index not allowed"); } return new Value(asList().get(index)); } // If this wasn't a slice you probably shouldn't be using this function return new Value(null); } /* ***************** * Utility * *****************/ public void decode() { if (!this.decoded) { this.value = RLP.decode(rlp, 0).getDecoded(); this.decoded = true; } } public byte[] encode() { if (rlp == null) rlp = RLP.encode(value); return rlp; } // public byte[] hash() { // if (sha3 == null) // sha3 = HashUtil.sha3(encode()); // return sha3; // } public boolean cmp(Value o) { return DeepEquals.deepEquals(this, o); } /* ***************** * Checks * *****************/ public boolean isList() { decode(); return value != null && value.getClass().isArray() && !value.getClass().getComponentType().isPrimitive(); } public boolean isString() { decode(); return value instanceof String; } public boolean isInt() { decode(); return value instanceof Integer; } public boolean isLong() { decode(); return value instanceof Long; } public boolean isBigInt() { decode(); return value instanceof BigInteger; } public boolean isBytes() { decode(); return value instanceof byte[]; } // it's only if the isBytes() = true; public boolean isReadableString() { decode(); int readableChars = 0; byte[] data = (byte[]) value; if (data.length == 1 && data[0] > 31 && data[0] < 126) { return true; } for (byte aData : data) { if (aData > 32 && aData < 126) ++readableChars; } return (double) readableChars / (double) data.length > 0.55; } // it's only if the isBytes() = true; public boolean isHexString() { decode(); int hexChars = 0; byte[] data = (byte[]) value; for (byte aData : data) { if ((aData >= 48 && aData <= 57) || (aData >= 97 && aData <= 102)) ++hexChars; } return (double) hexChars / (double) data.length > 0.9; } public boolean isHashCode() { decode(); return this.asBytes().length == 32; } public boolean isNull() { decode(); return value == null; } public boolean isEmpty() { decode(); if (isNull()) return true; if (isBytes() && asBytes().length == 0) return true; if (isList() && asList().isEmpty()) return true; if (isString() && asString().equals("")) return true; return false; } public int length() { decode(); if (isList()) { return asList().size(); } else if (isBytes()) { return asBytes().length; } else if (isString()) { return asString().length(); } return 0; } public String toString() { decode(); StringBuilder stringBuilder = new StringBuilder(); if (isList()) { Object[] list = (Object[]) value; // special case - key/value node if (list.length == 2) { stringBuilder.append("[ "); Value key = new Value(list[0]); byte[] keyNibbles = CompactEncoder.binToNibblesNoTerminator(key.asBytes()); String keyString = ByteUtil.nibblesToPrettyString(keyNibbles); stringBuilder.append(keyString); stringBuilder.append(","); Value val = new Value(list[1]); stringBuilder.append(val.toString()); stringBuilder.append(" ]"); return stringBuilder.toString(); } stringBuilder.append(" ["); for (int i = 0; i < list.length; ++i) { Value val = new Value(list[i]); if (val.isString() || val.isEmpty()) { stringBuilder.append("'").append(val.toString()).append("'"); } else { stringBuilder.append(val.toString()); } if (i < list.length - 1) stringBuilder.append(", "); } stringBuilder.append("] "); return stringBuilder.toString(); } else if (isEmpty()) { return ""; } else if (isBytes()) { StringBuilder output = new StringBuilder(); if (isHashCode()) { output.append(Hex.toHexString(asBytes())); } else if (isReadableString()) { output.append("'"); for (byte oneByte : asBytes()) { if (oneByte < 16) { output.append("\\x").append(ByteUtil.oneByteToHexString(oneByte)); } else { output.append(Character.valueOf((char) oneByte)); } } output.append("'"); return output.toString(); } return Hex.toHexString(this.asBytes()); } else if (isString()) { return asString(); } return "Unexpected type"; } public int countBranchNodes() { decode(); if (this.isList()) { List objList = this.asList(); int i = 0; for (Object obj : objList) { i += (new Value(obj)).countBranchNodes(); } return i; } else if (this.isBytes()) { this.asBytes(); } return 0; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/solidity/SolidityType.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.solidity; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; import com.quincysx.crypto.ethereum.utils.ByteUtil; import org.spongycastle.util.encoders.Hex; import java.io.UnsupportedEncodingException; import java.lang.reflect.Array; import java.math.BigInteger; import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public abstract class SolidityType { protected String name; public SolidityType(String name) { this.name = name; } /** * The type name as it was specified in the interface description */ public String getName() { return name; } /** * The canonical type name (used for the method signature creation) * E.g. 'int' - canonical 'int256' */ @JsonValue public String getCanonicalName() { return getName(); } @JsonCreator public static SolidityType getType(String typeName) { if (typeName.contains("[")) return ArrayType.getType(typeName); if ("bool".equals(typeName)) return new BoolType(); if (typeName.startsWith("int") || typeName.startsWith("uint")) return new IntType(typeName); if ("address".equals(typeName)) return new AddressType(); if ("string".equals(typeName)) return new StringType(); if ("bytes".equals(typeName)) return new BytesType(); if ("function".equals(typeName)) return new FunctionType(); if (typeName.startsWith("bytes")) return new Bytes32Type(typeName); throw new RuntimeException("Unknown type: " + typeName); } /** * Encodes the value according to specific type rules * * @param value */ public abstract byte[] encode(Object value); public abstract Object decode(byte[] encoded, int offset); public Object decode(byte[] encoded) { return decode(encoded, 0); } /** * @return fixed size in bytes. For the dynamic types returns IntType.getFixedSize() * which is effectively the int offset to dynamic data */ public int getFixedSize() { return 32; } public boolean isDynamicType() { return false; } @Override public String toString() { return getName(); } public static abstract class ArrayType extends SolidityType { public static ArrayType getType(String typeName) { int idx1 = typeName.indexOf("["); int idx2 = typeName.indexOf("]", idx1); if (idx1 + 1 == idx2) { return new DynamicArrayType(typeName); } else { return new StaticArrayType(typeName); } } SolidityType elementType; public ArrayType(String name) { super(name); int idx = name.indexOf("["); String st = name.substring(0, idx); int idx2 = name.indexOf("]", idx); String subDim = idx2 + 1 == name.length() ? "" : name.substring(idx2 + 1); elementType = SolidityType.getType(st + subDim); } @Override public byte[] encode(Object value) { if (value.getClass().isArray()) { List elems = new ArrayList<>(); for (int i = 0; i < Array.getLength(value); i++) { elems.add(Array.get(value, i)); } return encodeList(elems); } else if (value instanceof List) { return encodeList((List) value); } else { throw new RuntimeException("List value expected for type " + getName()); } } public SolidityType getElementType() { return elementType; } public abstract byte[] encodeList(List l); } public static class StaticArrayType extends ArrayType { int size; public StaticArrayType(String name) { super(name); int idx1 = name.indexOf("["); int idx2 = name.indexOf("]", idx1); String dim = name.substring(idx1 + 1, idx2); size = Integer.parseInt(dim); } @Override public String getCanonicalName() { return elementType.getCanonicalName() + "[" + size + "]"; } @Override public byte[] encodeList(List l) { if (l.size() != size) throw new RuntimeException("List size (" + l.size() + ") != " + size + " for type " + getName()); byte[][] elems = new byte[size][]; for (int i = 0; i < l.size(); i++) { elems[i] = elementType.encode(l.get(i)); } return ByteUtil.merge(elems); } @Override public Object[] decode(byte[] encoded, int offset) { Object[] result = new Object[size]; for (int i = 0; i < size; i++) { result[i] = elementType.decode(encoded, offset + i * elementType.getFixedSize()); } return result; } @Override public int getFixedSize() { // return negative if elementType is dynamic return elementType.getFixedSize() * size; } } public static class DynamicArrayType extends ArrayType { public DynamicArrayType(String name) { super(name); } @Override public String getCanonicalName() { return elementType.getCanonicalName() + "[]"; } @Override public byte[] encodeList(List l) { byte[][] elems; if (elementType.isDynamicType()) { elems = new byte[l.size() * 2 + 1][]; elems[0] = IntType.encodeInt(l.size()); int offset = l.size() * 32; for (int i = 0; i < l.size(); i++) { elems[i + 1] = IntType.encodeInt(offset); byte[] encoded = elementType.encode(l.get(i)); elems[l.size() + i + 1] = encoded; offset += 32 * ((encoded.length - 1) / 32 + 1); } } else { elems = new byte[l.size() + 1][]; elems[0] = IntType.encodeInt(l.size()); for (int i = 0; i < l.size(); i++) { elems[i + 1] = elementType.encode(l.get(i)); } } return ByteUtil.merge(elems); } @Override public Object decode(byte[] encoded, int origOffset) { int len = IntType.decodeInt(encoded, origOffset).intValue(); origOffset += 32; int offset = origOffset; Object[] ret = new Object[len]; for (int i = 0; i < len; i++) { if (elementType.isDynamicType()) { ret[i] = elementType.decode(encoded, origOffset + IntType.decodeInt(encoded, offset).intValue()); } else { ret[i] = elementType.decode(encoded, offset); } offset += elementType.getFixedSize(); } return ret; } @Override public boolean isDynamicType() { return true; } } public static class BytesType extends SolidityType { protected BytesType(String name) { super(name); } public BytesType() { super("bytes"); } @Override public byte[] encode(Object value) { byte[] bb; if (value instanceof byte[]) { bb = (byte[]) value; } else if (value instanceof String) { bb = ((String) value).getBytes(); } else { throw new RuntimeException("byte[] or String value is expected for type 'bytes'"); } byte[] ret = new byte[((bb.length - 1) / 32 + 1) * 32]; // padding 32 bytes System.arraycopy(bb, 0, ret, 0, bb.length); return ByteUtil.merge(IntType.encodeInt(bb.length), ret); } @Override public Object decode(byte[] encoded, int offset) { int len = IntType.decodeInt(encoded, offset).intValue(); if (len == 0) return new byte[0]; offset += 32; return Arrays.copyOfRange(encoded, offset, offset + len); } @Override public boolean isDynamicType() { return true; } } public static class StringType extends BytesType { public StringType() { super("string"); } @Override public byte[] encode(Object value) { if (!(value instanceof String)) throw new RuntimeException("String value expected for type 'string'"); // return super.encode(((String) value).getSignBytes(StandardCharsets.UTF_8)); try { return super.encode(((String) value).getBytes("UTF-8")); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } } @Override public Object decode(byte[] encoded, int offset) { try { return new String((byte[]) super.decode(encoded, offset), "UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } } } public static class Bytes32Type extends SolidityType { public Bytes32Type(String s) { super(s); } @Override public byte[] encode(Object value) { if (value instanceof Number) { BigInteger bigInt = new BigInteger(value.toString()); return IntType.encodeInt(bigInt); } else if (value instanceof String) { byte[] ret = new byte[32]; byte[] bytes = new byte[0]; try { bytes = ((String) value).getBytes("UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException(e); } System.arraycopy(bytes, 0, ret, 0, bytes.length); return ret; } else if (value instanceof byte[]) { byte[] bytes = (byte[]) value; byte[] ret = new byte[32]; System.arraycopy(bytes, 0, ret, 32 - bytes.length, bytes.length); return ret; } throw new RuntimeException("Can't encode java type " + value.getClass() + " to bytes32"); } @Override public Object decode(byte[] encoded, int offset) { return Arrays.copyOfRange(encoded, offset, offset + getFixedSize()); } } public static class AddressType extends IntType { public AddressType() { super("address"); } @Override public byte[] encode(Object value) { if (value instanceof String && !((String) value).startsWith("0x")) { // address is supposed to be always in hex value = "0x" + value; } byte[] addr = super.encode(value); for (int i = 0; i < 12; i++) { if (addr[i] != 0) { throw new RuntimeException("Invalid address (should be 20 bytes length): " + Hex.toHexString(addr)); } } return addr; } @Override public Object decode(byte[] encoded, int offset) { BigInteger bi = (BigInteger) super.decode(encoded, offset); return ByteUtil.bigIntegerToBytes(bi, 20); } } public static class IntType extends SolidityType { public IntType(String name) { super(name); } @Override public String getCanonicalName() { if (getName().equals("int")) return "int256"; if (getName().equals("uint")) return "uint256"; return super.getCanonicalName(); } @Override public byte[] encode(Object value) { BigInteger bigInt; if (value instanceof String) { String s = ((String) value).toLowerCase().trim(); int radix = 10; if (s.startsWith("0x")) { s = s.substring(2); radix = 16; } else if (s.contains("a") || s.contains("b") || s.contains("c") || s.contains("d") || s.contains("e") || s.contains("f")) { radix = 16; } bigInt = new BigInteger(s, radix); } else if (value instanceof BigInteger) { bigInt = (BigInteger) value; } else if (value instanceof Number) { bigInt = new BigInteger(value.toString()); } else if (value instanceof byte[]) { bigInt = ByteUtil.bytesToBigInteger((byte[]) value); } else { throw new RuntimeException("Invalid value for type '" + this + "': " + value + " (" + value.getClass() + ")"); } return encodeInt(bigInt); } @Override public Object decode(byte[] encoded, int offset) { return decodeInt(encoded, offset); } public static BigInteger decodeInt(byte[] encoded, int offset) { return new BigInteger(Arrays.copyOfRange(encoded, offset, offset + 32)); } public static byte[] encodeInt(int i) { return encodeInt(new BigInteger("" + i)); } public static byte[] encodeInt(BigInteger bigInt) { return ByteUtil.bigIntegerToBytesSigned(bigInt, 32); } } public static class BoolType extends IntType { public BoolType() { super("bool"); } @Override public byte[] encode(Object value) { if (!(value instanceof Boolean)) throw new RuntimeException("Wrong value for bool type: " + value); return super.encode(value == Boolean.TRUE ? 1 : 0); } @Override public Object decode(byte[] encoded, int offset) { return Boolean.valueOf(((Number) super.decode(encoded, offset)).intValue() != 0); } } public static class FunctionType extends Bytes32Type { public FunctionType() { super("function"); } @Override public byte[] encode(Object value) { if (!(value instanceof byte[])) throw new RuntimeException("Expected byte[] value for FunctionType"); if (((byte[]) value).length != 24) throw new RuntimeException("Expected byte[24] for FunctionType"); return super.encode(ByteUtil.merge((byte[]) value, new byte[8])); } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/utils/ByteUtil.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.utils; import org.spongycastle.util.encoders.Hex; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.math.BigInteger; import java.net.InetAddress; import java.net.UnknownHostException; import java.nio.ByteBuffer; import java.util.Arrays; import java.util.HashSet; import java.util.Set; public class ByteUtil { public static final byte[] EMPTY_BYTE_ARRAY = new byte[0]; public static final byte[] ZERO_BYTE_ARRAY = new byte[]{0}; /** * Creates a copy of bytes and appends b to the end of it */ public static byte[] appendByte(byte[] bytes, byte b) { byte[] result = Arrays.copyOf(bytes, bytes.length + 1); result[result.length - 1] = b; return result; } /** * The regular {@link BigInteger#toByteArray()} method isn't quite what we often need: * it appends a leading zero to indicate that the number is positive and may need padding. * * @param b the integer to format into a byte array * @param numBytes the desired size of the resulting byte array * @return numBytes byte long array. */ public static byte[] bigIntegerToBytes(BigInteger b, int numBytes) { if (b == null) return null; byte[] bytes = new byte[numBytes]; byte[] biBytes = b.toByteArray(); int start = (biBytes.length == numBytes + 1) ? 1 : 0; int length = Math.min(biBytes.length, numBytes); System.arraycopy(biBytes, start, bytes, numBytes - length, length); return bytes; } public static byte[] bigIntegerToBytesSigned(BigInteger b, int numBytes) { if (b == null) return null; byte[] bytes = new byte[numBytes]; Arrays.fill(bytes, b.signum() < 0 ? (byte) 0xFF : 0x00); byte[] biBytes = b.toByteArray(); int start = (biBytes.length == numBytes + 1) ? 1 : 0; int length = Math.min(biBytes.length, numBytes); System.arraycopy(biBytes, start, bytes, numBytes - length, length); return bytes; } /** * Omitting sign indication byte. *

* Instead of {@link org.spongycastle.util.BigIntegers#asUnsignedByteArray(BigInteger)} *
we use this custom method to avoid an empty array in case of BigInteger.ZERO * * @param value - any big integer number. A null-value will return null * @return A byte array without a leading zero byte if present in the signed encoding. * BigInteger.ZERO will return an array with length 1 and byte-value 0. */ public static byte[] bigIntegerToBytes(BigInteger value) { if (value == null) return null; byte[] data = value.toByteArray(); if (data.length != 1 && data[0] == 0) { byte[] tmp = new byte[data.length - 1]; System.arraycopy(data, 1, tmp, 0, tmp.length); data = tmp; } return data; } /** * Cast hex encoded value from byte[] to BigInteger * null is parsed like byte[0] * * @param bb byte array contains the values * @return unsigned positive BigInteger value. */ public static BigInteger bytesToBigInteger(byte[] bb) { return (bb == null || bb.length == 0) ? BigInteger.ZERO : new BigInteger(1, bb); } /** * Returns the amount of nibbles that match each other from 0 ... * amount will never be larger than smallest input * * @param a - first input * @param b - second input * @return Number of bytes that match */ public static int matchingNibbleLength(byte[] a, byte[] b) { int i = 0; int length = a.length < b.length ? a.length : b.length; while (i < length) { if (a[i] != b[i]) return i; i++; } return i; } /** * Converts a long value into a byte array. * * @param val - long value to convert * @return byte[] of length 8, representing the long value */ public static byte[] longToBytes(long val) { return ByteBuffer.allocate(Long.BYTES).putLong(val).array(); } /** * Converts a long value into a byte array. * * @param val - long value to convert * @return decimal value with leading byte that are zeroes striped */ public static byte[] longToBytesNoLeadZeroes(long val) { // todo: improve performance by while strip numbers until (long >> 8 == 0) if (val == 0) return EMPTY_BYTE_ARRAY; byte[] data = ByteBuffer.allocate(Long.BYTES).putLong(val).array(); return stripLeadingZeroes(data); } /** * Converts int value into a byte array. * * @param val - int value to convert * @return byte[] of length 4, representing the int value */ public static byte[] intToBytes(int val){ return ByteBuffer.allocate(Integer.BYTES).putInt(val).array(); } /** * Converts a int value into a byte array. * * @param val - int value to convert * @return value with leading byte that are zeroes striped */ public static byte[] intToBytesNoLeadZeroes(int val){ if (val == 0) return EMPTY_BYTE_ARRAY; int lenght = 0; int tmpVal = val; while (tmpVal != 0){ tmpVal = tmpVal >>> 8; ++lenght; } byte[] result = new byte[lenght]; int index = result.length - 1; while(val != 0){ result[index] = (byte)(val & 0xFF); val = val >>> 8; index -= 1; } return result; } /** * Convert a byte-array into a hex String.
* Works similar to {@link Hex#toHexString} * but allows for null * * @param data - byte-array to convert to a hex-string * @return hex representation of the data.
* Returns an empty String if the input is null * * @see Hex#toHexString */ public static String toHexString(byte[] data) { return data == null ? "" : Hex.toHexString(data); } /** * Calculate packet length * * @param msg byte[] * @return byte-array with 4 elements */ public static byte[] calcPacketLength(byte[] msg) { int msgLen = msg.length; return new byte[]{ (byte) ((msgLen >> 24) & 0xFF), (byte) ((msgLen >> 16) & 0xFF), (byte) ((msgLen >> 8) & 0xFF), (byte) ((msgLen) & 0xFF)}; } /** * Cast hex encoded value from byte[] to int * null is parsed like byte[0] * * Limited to Integer.MAX_VALUE: 2^32-1 (4 bytes) * * @param b array contains the values * @return unsigned positive int value. */ public static int byteArrayToInt(byte[] b) { if (b == null || b.length == 0) return 0; return new BigInteger(1, b).intValue(); } /** * Cast hex encoded value from byte[] to long * null is parsed like byte[0] * * Limited to Long.MAX_VALUE: 263-1 (8 bytes) * * @param b array contains the values * @return unsigned positive long value. */ public static long byteArrayToLong(byte[] b) { if (b == null || b.length == 0) return 0; return new BigInteger(1, b).longValue(); } /** * Turn nibbles to a pretty looking output string * * Example. [ 1, 2, 3, 4, 5 ] becomes '\x11\x23\x45' * * @param nibbles - getting byte of data [ 04 ] and turning * it to a '\x04' representation * @return pretty string of nibbles */ public static String nibblesToPrettyString(byte[] nibbles) { StringBuilder builder = new StringBuilder(); for (byte nibble : nibbles) { final String nibbleString = oneByteToHexString(nibble); builder.append("\\x").append(nibbleString); } return builder.toString(); } public static String oneByteToHexString(byte value) { String retVal = Integer.toString(value & 0xFF, 16); if (retVal.length() == 1) retVal = "0" + retVal; return retVal; } /** * Calculate the number of bytes need * to encode the number * * @param val - number * @return number of min bytes used to encode the number */ public static int numBytes(String val) { BigInteger bInt = new BigInteger(val); int bytes = 0; while (!bInt.equals(BigInteger.ZERO)) { bInt = bInt.shiftRight(8); ++bytes; } if (bytes == 0) ++bytes; return bytes; } /** * @param arg - not more that 32 bits * @return - bytes of the value pad with complete to 32 zeroes */ public static byte[] encodeValFor32Bits(Object arg) { byte[] data; // check if the string is numeric if (arg.toString().trim().matches("-?\\d+(\\.\\d+)?")) data = new BigInteger(arg.toString().trim()).toByteArray(); // check if it's hex number else if (arg.toString().trim().matches("0[xX][0-9a-fA-F]+")) data = new BigInteger(arg.toString().trim().substring(2), 16).toByteArray(); else data = arg.toString().trim().getBytes(); if (data.length > 32) throw new RuntimeException("values can't be more than 32 byte"); byte[] val = new byte[32]; int j = 0; for (int i = data.length; i > 0; --i) { val[31 - j] = data[i - 1]; ++j; } return val; } /** * encode the values and concatenate together * * @param args Object * @return byte[] */ public static byte[] encodeDataList(Object... args) { ByteArrayOutputStream baos = new ByteArrayOutputStream(); for (Object arg : args) { byte[] val = encodeValFor32Bits(arg); try { baos.write(val); } catch (IOException e) { throw new Error("Happen something that should never happen ", e); } } return baos.toByteArray(); } public static int firstNonZeroByte(byte[] data) { for (int i = 0; i < data.length; ++i) { if (data[i] != 0) { return i; } } return -1; } public static byte[] stripLeadingZeroes(byte[] data) { if (data == null) return null; final int firstNonZero = firstNonZeroByte(data); switch (firstNonZero) { case -1: return ZERO_BYTE_ARRAY; case 0: return data; default: byte[] result = new byte[data.length - firstNonZero]; System.arraycopy(data, firstNonZero, result, 0, data.length - firstNonZero); return result; } } /** * increment byte array as a number until max is reached * * @param bytes byte[] * @return boolean */ public static boolean increment(byte[] bytes) { final int startIndex = 0; int i; for (i = bytes.length - 1; i >= startIndex; i--) { bytes[i]++; if (bytes[i] != 0) break; } // we return false when all bytes are 0 again return (i >= startIndex || bytes[startIndex] != 0); } /** * Utility function to copy a byte array into a new byte array with given size. * If the src length is smaller than the given size, the result will be left-padded * with zeros. * * @param value - a BigInteger with a maximum value of 2^256-1 * @return Byte array of given size with a copy of the src */ public static byte[] copyToArray(BigInteger value) { byte[] src = ByteUtil.bigIntegerToBytes(value); byte[] dest = ByteBuffer.allocate(32).array(); System.arraycopy(src, 0, dest, dest.length - src.length, src.length); return dest; } // public static ByteArrayWrapper wrap(byte[] data) { // return new ByteArrayWrapper(data); // } public static byte[] setBit(byte[] data, int pos, int val) { if ((data.length * 8) - 1 < pos) throw new Error("outside byte array limit, pos: " + pos); int posByte = data.length - 1 - (pos) / 8; int posBit = (pos) % 8; byte setter = (byte) (1 << (posBit)); byte toBeSet = data[posByte]; byte result; if (val == 1) result = (byte) (toBeSet | setter); else result = (byte) (toBeSet & ~setter); data[posByte] = result; return data; } public static int getBit(byte[] data, int pos) { if ((data.length * 8) - 1 < pos) throw new Error("outside byte array limit, pos: " + pos); int posByte = data.length - 1 - pos / 8; int posBit = pos % 8; byte dataByte = data[posByte]; return Math.min(1, (dataByte & (1 << (posBit)))); } public static byte[] and(byte[] b1, byte[] b2) { if (b1.length != b2.length) throw new RuntimeException("Array sizes differ"); byte[] ret = new byte[b1.length]; for (int i = 0; i < ret.length; i++) { ret[i] = (byte) (b1[i] & b2[i]); } return ret; } public static byte[] or(byte[] b1, byte[] b2) { if (b1.length != b2.length) throw new RuntimeException("Array sizes differ"); byte[] ret = new byte[b1.length]; for (int i = 0; i < ret.length; i++) { ret[i] = (byte) (b1[i] | b2[i]); } return ret; } public static byte[] xor(byte[] b1, byte[] b2) { if (b1.length != b2.length) throw new RuntimeException("Array sizes differ"); byte[] ret = new byte[b1.length]; for (int i = 0; i < ret.length; i++) { ret[i] = (byte) (b1[i] ^ b2[i]); } return ret; } /** * XORs byte arrays of different lengths by aligning length of the shortest via adding zeros at beginning */ public static byte[] xorAlignRight(byte[] b1, byte[] b2) { if (b1.length > b2.length) { byte[] b2_ = new byte[b1.length]; System.arraycopy(b2, 0, b2_, b1.length - b2.length, b2.length); b2 = b2_; } else if (b2.length > b1.length) { byte[] b1_ = new byte[b2.length]; System.arraycopy(b1, 0, b1_, b2.length - b1.length, b1.length); b1 = b1_; } return xor(b1, b2); } /** * @param arrays - arrays to merge * @return - merged array */ public static byte[] merge(byte[]... arrays) { int arrCount = 0; int count = 0; for (byte[] array: arrays) { arrCount++; count += array.length; } // Create new array and copy all array contents byte[] mergedArray = new byte[count]; int start = 0; for (byte[] array: arrays) { System.arraycopy(array, 0, mergedArray, start, array.length); start += array.length; } return mergedArray; } public static boolean isNullOrZeroArray(byte[] array){ return (array == null) || (array.length == 0); } public static boolean isSingleZero(byte[] array){ return (array.length == 1 && array[0] == 0); } public static Set difference(Set setA, Set setB){ Set result = new HashSet<>(); for (byte[] elementA : setA){ boolean found = false; for (byte[] elementB : setB){ if (Arrays.equals(elementA, elementB)){ found = true; break; } } if (!found) result.add(elementA); } return result; } public static int length(byte[]... bytes) { int result = 0; for (byte[] array : bytes) { result += (array == null) ? 0 : array.length; } return result; } public static byte[] intsToBytes(int[] arr, boolean bigEndian) { byte[] ret = new byte[arr.length * 4]; intsToBytes(arr, ret, bigEndian); return ret; } public static int[] bytesToInts(byte[] arr, boolean bigEndian) { int[] ret = new int[arr.length / 4]; bytesToInts(arr, ret, bigEndian); return ret; } public static void bytesToInts(byte[] b, int[] arr, boolean bigEndian) { if (!bigEndian) { int off = 0; for (int i = 0; i < arr.length; i++) { int ii = b[off++] & 0x000000FF; ii |= (b[off++] << 8) & 0x0000FF00; ii |= (b[off++] << 16) & 0x00FF0000; ii |= (b[off++] << 24); arr[i] = ii; } } else { int off = 0; for (int i = 0; i < arr.length; i++) { int ii = b[off++] << 24; ii |= (b[off++] << 16) & 0x00FF0000; ii |= (b[off++] << 8) & 0x0000FF00; ii |= b[off++] & 0x000000FF; arr[i] = ii; } } } public static void intsToBytes(int[] arr, byte[] b, boolean bigEndian) { if (!bigEndian) { int off = 0; for (int i = 0; i < arr.length; i++) { int ii = arr[i]; b[off++] = (byte) (ii & 0xFF); b[off++] = (byte) ((ii >> 8) & 0xFF); b[off++] = (byte) ((ii >> 16) & 0xFF); b[off++] = (byte) ((ii >> 24) & 0xFF); } } else { int off = 0; for (int i = 0; i < arr.length; i++) { int ii = arr[i]; b[off++] = (byte) ((ii >> 24) & 0xFF); b[off++] = (byte) ((ii >> 16) & 0xFF); b[off++] = (byte) ((ii >> 8) & 0xFF); b[off++] = (byte) (ii & 0xFF); } } } public static short bigEndianToShort(byte[] bs) { return bigEndianToShort(bs, 0); } public static short bigEndianToShort(byte[] bs, int off) { int n = bs[off] << 8; ++off; n |= bs[off] & 0xFF; return (short) n; } public static byte[] shortToBytes(short n) { return ByteBuffer.allocate(2).putShort(n).array(); } /** * Converts string hex representation to data bytes * Accepts following hex: * - with or without 0x prefix * - with no leading 0, like 0xabc -> 0x0abc * @param data String like '0xa5e..' or just 'a5e..' * @return decoded bytes array */ public static byte[] hexStringToBytes(String data) { if (data == null) return EMPTY_BYTE_ARRAY; if (data.startsWith("0x")) data = data.substring(2); if (data.length() % 2 == 1) data = "0" + data; return Hex.decode(data); } /** * Converts string representation of host/ip to 4-bytes byte[] IPv4 */ public static byte[] hostToBytes(String ip) { byte[] bytesIp; try { bytesIp = InetAddress.getByName(ip).getAddress(); } catch (UnknownHostException e) { bytesIp = new byte[4]; // fall back to invalid 0.0.0.0 address } return bytesIp; } /** * Converts 4 bytes IPv4 IP to String representation */ public static String bytesToIp(byte[] bytesIp) { StringBuilder sb = new StringBuilder(); sb.append(bytesIp[0] & 0xFF); sb.append("."); sb.append(bytesIp[1] & 0xFF); sb.append("."); sb.append(bytesIp[2] & 0xFF); sb.append("."); sb.append(bytesIp[3] & 0xFF); String ip = sb.toString(); return ip; } /** * Returns a number of zero bits preceding the highest-order ("leftmost") one-bit * interpreting input array as a big-endian integer value */ public static int numberOfLeadingZeros(byte[] bytes) { int i = firstNonZeroByte(bytes); if (i == -1) { return bytes.length * 8; } else { int byteLeadingZeros = Integer.numberOfLeadingZeros((int)bytes[i] & 0xff) - 24; return i * 8 + byteLeadingZeros; } } /** * Parses fixed number of bytes starting from {@code offset} in {@code input} array. * If {@code input} has not enough bytes return array will be right padded with zero bytes. * I.e. if {@code offset} is higher than {@code input.length} then zero byte array of length {@code len} will be returned */ public static byte[] parseBytes(byte[] input, int offset, int len) { if (offset >= input.length || len == 0) return EMPTY_BYTE_ARRAY; byte[] bytes = new byte[len]; System.arraycopy(input, offset, bytes, 0, Math.min(input.length - offset, len)); return bytes; } /** * Parses 32-bytes word from given input. * Uses {@link #parseBytes(byte[], int, int)} method, * thus, result will be right-padded with zero bytes if there is not enough bytes in {@code input} * * @param idx an index of the word starting from {@code 0} */ public static byte[] parseWord(byte[] input, int idx) { return parseBytes(input, 32 * idx, 32); } /** * Parses 32-bytes word from given input. * Uses {@link #parseBytes(byte[], int, int)} method, * thus, result will be right-padded with zero bytes if there is not enough bytes in {@code input} * * @param idx an index of the word starting from {@code 0} * @param offset an offset in {@code input} array to start parsing from */ public static byte[] parseWord(byte[] input, int offset, int idx) { return parseBytes(input, offset + 32 * idx, 32); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/utils/FastByteComparisons.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ /** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.quincysx.crypto.ethereum.utils; /** * Utility code to do optimized byte-array comparison. * This is borrowed and slightly modified from Guava's * class to be able to compare arrays that start at non-zero offsets. */ @SuppressWarnings("restriction") public abstract class FastByteComparisons { public static boolean equal(byte[] b1, byte[] b2) { return b1.length == b2.length && compareTo(b1, 0, b1.length, b2, 0, b2.length) == 0; } /** * Lexicographically compare two byte arrays. * * @param b1 buffer1 * @param s1 offset1 * @param l1 length1 * @param b2 buffer2 * @param s2 offset2 * @param l2 length2 * @return int */ public static int compareTo(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { return LexicographicalComparerHolder.BEST_COMPARER.compareTo( b1, s1, l1, b2, s2, l2); } private interface Comparer { int compareTo(T buffer1, int offset1, int length1, T buffer2, int offset2, int length2); } private static Comparer lexicographicalComparerJavaImpl() { return LexicographicalComparerHolder.PureJavaComparer.INSTANCE; } /** * *

Uses reflection to gracefully fall back to the Java implementation if * {@code Unsafe} isn't available. */ private static class LexicographicalComparerHolder { static final String UNSAFE_COMPARER_NAME = LexicographicalComparerHolder.class.getName() + "$UnsafeComparer"; static final Comparer BEST_COMPARER = getBestComparer(); /** * Returns the Unsafe-using Comparer, or falls back to the pure-Java * implementation if unable to do so. */ static Comparer getBestComparer() { try { Class theClass = Class.forName(UNSAFE_COMPARER_NAME); // yes, UnsafeComparer does implement Comparer @SuppressWarnings("unchecked") Comparer comparer = (Comparer) theClass.getEnumConstants()[0]; return comparer; } catch (Throwable t) { // ensure we really catch *everything* return lexicographicalComparerJavaImpl(); } } private enum PureJavaComparer implements Comparer { INSTANCE; @Override public int compareTo(byte[] buffer1, int offset1, int length1, byte[] buffer2, int offset2, int length2) { // Short circuit equal case if (buffer1 == buffer2 && offset1 == offset2 && length1 == length2) { return 0; } int end1 = offset1 + length1; int end2 = offset2 + length2; for (int i = offset1, j = offset2; i < end1 && j < end2; i++, j++) { int a = (buffer1[i] & 0xff); int b = (buffer2[j] & 0xff); if (a != b) { return a - b; } } return length1 - length2; } } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/vm/DataWord.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.vm; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonValue; import com.quincysx.crypto.ethereum.ByteArrayWrapper; import com.quincysx.crypto.ethereum.utils.ByteUtil; import com.quincysx.crypto.ethereum.utils.FastByteComparisons; import org.spongycastle.util.Arrays; import org.spongycastle.util.encoders.Hex; import java.math.BigInteger; import java.nio.ByteBuffer; /** * DataWord is the 32-byte array representation of a 256-bit number * Calculations can be done on this word with other DataWords * * @author Roman Mandeleil * @since 01.06.2014 */ public class DataWord implements Comparable { /* Maximum value of the DataWord */ public static final BigInteger _2_256 = BigInteger.valueOf(2).pow(256); public static final BigInteger MAX_VALUE = _2_256.subtract(BigInteger.ONE); public static final DataWord ZERO = new DataWord(new byte[32]); // don't push it in to the stack public static final DataWord ZERO_EMPTY_ARRAY = new DataWord(new byte[0]); // don't push it in to the stack private byte[] data = new byte[32]; public DataWord() { } public DataWord(int num) { this(ByteBuffer.allocate(4).putInt(num)); } public DataWord(long num) { this(ByteBuffer.allocate(8).putLong(num)); } private DataWord(ByteBuffer buffer) { final ByteBuffer data = ByteBuffer.allocate(32); final byte[] array = buffer.array(); System.arraycopy(array, 0, data.array(), 32 - array.length, array.length); this.data = data.array(); } @JsonCreator public DataWord(String data) { this(Hex.decode(data)); } public DataWord(ByteArrayWrapper wrappedData){ this(wrappedData.getData()); } public DataWord(byte[] data) { if (data == null) this.data = ByteUtil.EMPTY_BYTE_ARRAY; else if (data.length == 32) this.data = data; else if (data.length <= 32) System.arraycopy(data, 0, this.data, 32 - data.length, data.length); else throw new RuntimeException("Data word can't exceed 32 bytes: " + data); } public byte[] getData() { return data; } public byte[] getNoLeadZeroesData() { return ByteUtil.stripLeadingZeroes(data); } public byte[] getLast20Bytes() { return Arrays.copyOfRange(data, 12, data.length); } public BigInteger value() { return new BigInteger(1, data); } /** * Converts this DataWord to an int, checking for lost information. * If this DataWord is out of the possible range for an int result * then an ArithmeticException is thrown. * * @return this DataWord converted to an int. * @throws ArithmeticException - if this will not fit in an int. */ public int intValue() { int intVal = 0; for (int i = 0; i < data.length; i++) { intVal = (intVal << 8) + (data[i] & 0xff); } return intVal; } /** * In case of int overflow returns Integer.MAX_VALUE * otherwise works as #intValue() */ public int intValueSafe() { int bytesOccupied = bytesOccupied(); int intValue = intValue(); if (bytesOccupied > 4 || intValue < 0) return Integer.MAX_VALUE; return intValue; } /** * Converts this DataWord to a long, checking for lost information. * If this DataWord is out of the possible range for a long result * then an ArithmeticException is thrown. * * @return this DataWord converted to a long. * @throws ArithmeticException - if this will not fit in a long. */ public long longValue() { long longVal = 0; for (int i = 0; i < data.length; i++) { longVal = (longVal << 8) + (data[i] & 0xff); } return longVal; } /** * In case of long overflow returns Long.MAX_VALUE * otherwise works as #longValue() */ public long longValueSafe() { int bytesOccupied = bytesOccupied(); long longValue = longValue(); if (bytesOccupied > 8 || longValue < 0) return Long.MAX_VALUE; return longValue; } public BigInteger sValue() { return new BigInteger(data); } public String bigIntValue() { return new BigInteger(data).toString(); } public boolean isZero() { for (byte tmp : data) { if (tmp != 0) return false; } return true; } // only in case of signed operation // when the number is explicit defined // as negative public boolean isNegative() { int result = data[0] & 0x80; return result == 0x80; } public DataWord and(DataWord w2) { for (int i = 0; i < this.data.length; ++i) { this.data[i] &= w2.data[i]; } return this; } public DataWord or(DataWord w2) { for (int i = 0; i < this.data.length; ++i) { this.data[i] |= w2.data[i]; } return this; } public DataWord xor(DataWord w2) { for (int i = 0; i < this.data.length; ++i) { this.data[i] ^= w2.data[i]; } return this; } public void negate() { if (this.isZero()) return; for (int i = 0; i < this.data.length; ++i) { this.data[i] = (byte) ~this.data[i]; } for (int i = this.data.length - 1; i >= 0; --i) { this.data[i] = (byte) (1 + this.data[i] & 0xFF); if (this.data[i] != 0) break; } } public void bnot() { if (this.isZero()) { this.data = ByteUtil.copyToArray(MAX_VALUE); return; } this.data = ByteUtil.copyToArray(MAX_VALUE.subtract(this.value())); } // By : Holger // From : http://stackoverflow.com/a/24023466/459349 public void add(DataWord word) { byte[] result = new byte[32]; for (int i = 31, overflow = 0; i >= 0; i--) { int v = (this.data[i] & 0xff) + (word.data[i] & 0xff) + overflow; result[i] = (byte) v; overflow = v >>> 8; } this.data = result; } // old add-method with BigInteger quick hack public void add2(DataWord word) { BigInteger result = value().add(word.value()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } // TODO: mul can be done in more efficient way // TODO: with shift left shift right trick // TODO without BigInteger quick hack public void mul(DataWord word) { BigInteger result = value().multiply(word.value()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } // TODO: improve with no BigInteger public void div(DataWord word) { if (word.isZero()) { this.and(ZERO); return; } BigInteger result = value().divide(word.value()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } // TODO: improve with no BigInteger public void sDiv(DataWord word) { if (word.isZero()) { this.and(ZERO); return; } BigInteger result = sValue().divide(word.sValue()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } // TODO: improve with no BigInteger public void sub(DataWord word) { BigInteger result = value().subtract(word.value()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } // TODO: improve with no BigInteger public void exp(DataWord word) { BigInteger result = value().modPow(word.value(), _2_256); this.data = ByteUtil.copyToArray(result); } // TODO: improve with no BigInteger public void mod(DataWord word) { if (word.isZero()) { this.and(ZERO); return; } BigInteger result = value().mod(word.value()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } public void sMod(DataWord word) { if (word.isZero()) { this.and(ZERO); return; } BigInteger result = sValue().abs().mod(word.sValue().abs()); result = (sValue().signum() == -1) ? result.negate() : result; this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } public void addmod(DataWord word1, DataWord word2) { if (word2.isZero()) { this.data = new byte[32]; return; } BigInteger result = value().add(word1.value()).mod(word2.value()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } public void mulmod(DataWord word1, DataWord word2) { if (this.isZero() || word1.isZero() || word2.isZero()) { this.data = new byte[32]; return; } BigInteger result = value().multiply(word1.value()).mod(word2.value()); this.data = ByteUtil.copyToArray(result.and(MAX_VALUE)); } @JsonValue @Override public String toString() { return Hex.toHexString(data); } public String toPrefixString() { byte[] pref = getNoLeadZeroesData(); if (pref.length == 0) return ""; if (pref.length < 7) return Hex.toHexString(pref); return Hex.toHexString(pref).substring(0, 6); } public String shortHex() { String hexValue = Hex.toHexString(getNoLeadZeroesData()).toUpperCase(); return "0x" + hexValue.replaceFirst("^0+(?!$)", ""); } public DataWord clone() { return new DataWord(Arrays.clone(data)); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; DataWord dataWord = (DataWord) o; return java.util.Arrays.equals(data, dataWord.data); } @Override public int hashCode() { return java.util.Arrays.hashCode(data); } @Override public int compareTo(DataWord o) { if (o == null || o.getData() == null) return -1; int result = FastByteComparisons.compareTo( data, 0, data.length, o.getData(), 0, o.getData().length); // Convert result into -1, 0 or 1 as is the convention return (int) Math.signum(result); } public void signExtend(byte k) { if (0 > k || k > 31) throw new IndexOutOfBoundsException(); byte mask = this.sValue().testBit((k * 8) + 7) ? (byte) 0xff : 0; for (int i = 31; i > k; i--) { this.data[31 - i] = mask; } } public int bytesOccupied() { int firstNonZero = ByteUtil.firstNonZeroByte(data); if (firstNonZero == -1) return 0; return 31 - firstNonZero + 1; } public boolean isHex(String hex) { return Hex.toHexString(data).equals(hex); } public String asString(){ return new String(getNoLeadZeroesData()); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/ethereum/vm/LogInfo.java ================================================ /* * Copyright (c) [2016] [ ] * This file is part of the ethereumJ library. * * The ethereumJ library is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * The ethereumJ library 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with the ethereumJ library. If not, see . */ package com.quincysx.crypto.ethereum.vm; import com.quincysx.crypto.ethereum.Bloom; import com.quincysx.crypto.ethereum.rlp.RLP; import com.quincysx.crypto.ethereum.rlp.RLPElement; import com.quincysx.crypto.ethereum.rlp.RLPItem; import com.quincysx.crypto.ethereum.rlp.RLPList; import com.quincysx.crypto.utils.KECCAK256; import org.spongycastle.util.encoders.Hex; import java.util.ArrayList; import java.util.List; /** * @author Roman Mandeleil * @since 19.11.2014 */ public class LogInfo { byte[] address = new byte[]{}; List topics = new ArrayList<>(); byte[] data = new byte[]{}; /* Log info in encoded form */ private byte[] rlpEncoded; public LogInfo(byte[] rlp) { RLPList params = RLP.decode2(rlp); RLPList logInfo = (RLPList) params.get(0); RLPItem address = (RLPItem) logInfo.get(0); RLPList topics = (RLPList) logInfo.get(1); RLPItem data = (RLPItem) logInfo.get(2); this.address = address.getRLPData() != null ? address.getRLPData() : new byte[]{}; this.data = data.getRLPData() != null ? data.getRLPData() : new byte[]{}; for (RLPElement topic1 : topics) { byte[] topic = topic1.getRLPData(); this.topics.add(new DataWord(topic)); } rlpEncoded = rlp; } public LogInfo(byte[] address, List topics, byte[] data) { this.address = (address != null) ? address : new byte[]{}; this.topics = (topics != null) ? topics : new ArrayList(); this.data = (data != null) ? data : new byte[]{}; } public byte[] getAddress() { return address; } public List getTopics() { return topics; } public byte[] getData() { return data; } /* [address, [topic, topic ...] data] */ public byte[] getEncoded() { byte[] addressEncoded = RLP.encodeElement(this.address); byte[][] topicsEncoded = null; if (topics != null) { topicsEncoded = new byte[topics.size()][]; int i = 0; for (DataWord topic : topics) { byte[] topicData = topic.getData(); topicsEncoded[i] = RLP.encodeElement(topicData); ++i; } } byte[] dataEncoded = RLP.encodeElement(data); return RLP.encodeList(addressEncoded, RLP.encodeList(topicsEncoded), dataEncoded); } public Bloom getBloom() { // Bloom ret = Bloom.create(HashUtil.sha3(address)); Bloom ret = Bloom.create(KECCAK256.keccak256(address)); for (DataWord topic : topics) { byte[] topicData = topic.getData(); // ret.or(Bloom.create(HashUtil.sha3(topicData))); ret.or(Bloom.create(KECCAK256.keccak256(topicData))); } return ret; } @Override public String toString() { StringBuilder topicsStr = new StringBuilder(); topicsStr.append("["); for (DataWord topic : topics) { String topicStr = Hex.toHexString(topic.getData()); topicsStr.append(topicStr).append(" "); } topicsStr.append("]"); return "LogInfo{" + "address=" + Hex.toHexString(address) + ", topics=" + topicsStr + ", data=" + Hex.toHexString(data) + '}'; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/exception/CoinNotFindException.java ================================================ package com.quincysx.crypto.exception; /** * Created by q7728 on 2018/3/18. */ public class CoinNotFindException extends Exception { public CoinNotFindException(String message) { super(message); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/exception/NonSupportException.java ================================================ package com.quincysx.crypto.exception; /** * Created by q7728 on 2018/3/18. */ public class NonSupportException extends Exception { public NonSupportException(String message) { super(message); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/BTCUtils.java ================================================ package com.quincysx.crypto.utils; import com.quincysx.crypto.bitcoin.BTCTransaction; import org.spongycastle.asn1.ASN1InputStream; import org.spongycastle.asn1.ASN1Integer; import org.spongycastle.asn1.DLSequence; import org.spongycastle.asn1.sec.SECNamedCurves; import org.spongycastle.asn1.x9.X9ECParameters; import org.spongycastle.crypto.digests.SHA256Digest; import org.spongycastle.crypto.params.ECDomainParameters; import org.spongycastle.crypto.params.ECPublicKeyParameters; import org.spongycastle.crypto.signers.ECDSASigner; import org.spongycastle.crypto.signers.HMacDSAKCalculator; import java.io.IOException; import java.math.BigInteger; import java.util.Stack; /** * @author QuincySx * @date 2018/3/2 下午3:13 */ public class BTCUtils { public static byte[] reverse(byte[] bytes) { byte[] result = new byte[bytes.length]; for (int i = 0; i < bytes.length; i++) { result[i] = bytes[bytes.length - i - 1]; } return result; } public static void verify(BTCTransaction.Script[] scripts, BTCTransaction spendTx) throws BTCTransaction.Script.ScriptInvalidException { for (int i = 0; i < scripts.length; i++) { Stack stack = new Stack<>(); spendTx.inputs[i].script.run(stack);//load signature+public key scripts[i].run(i, spendTx, stack); //verify that this transaction able to spend that output if (BTCTransaction.Script.verifyFails(stack)) { throw new BTCTransaction.Script.ScriptInvalidException("Signature is invalid"); } } } public static boolean verify(byte[] publicKey, byte[] signature, byte[] msg) { X9ECParameters params = SECNamedCurves.getByName("secp256k1"); ECDomainParameters EC_PARAMS = new ECDomainParameters(params.getCurve(), params.getG(), params.getN(), params.getH()); synchronized (EC_PARAMS) { boolean valid; ECDSASigner signerVer = new ECDSASigner(new HMacDSAKCalculator(new SHA256Digest())); try { ECPublicKeyParameters pubKey = new ECPublicKeyParameters(EC_PARAMS.getCurve().decodePoint(publicKey), EC_PARAMS); signerVer.init(false, pubKey); ASN1InputStream derSigStream = new ASN1InputStream(signature); DLSequence seq = (DLSequence) derSigStream.readObject(); BigInteger r = ((ASN1Integer) seq.getObjectAt(0)).getPositiveValue(); BigInteger s = ((ASN1Integer) seq.getObjectAt(1)).getPositiveValue(); derSigStream.close(); valid = signerVer.verifySignature(msg, r, s); } catch (IOException e) { throw new RuntimeException(); } return valid; } } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/Base58.java ================================================ package com.quincysx.crypto.utils; import java.math.BigInteger; /** * @author QuincySx * @date 2018/3/1 下午5:04 */ public final class Base58 { private static final char[] BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".toCharArray(); private static final int BASE58_CHUNK_DIGITS = 10;//how many base 58 digits fits in long private static final BigInteger BASE58_CHUNK_MOD = BigInteger.valueOf(0x5fa8624c7fba400L); //58^BASE58_CHUNK_DIGITS private static final byte[] BASE58_VALUES = new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -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, -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, -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, -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}; public static byte[] decode(String input) { if (input == null) { return null; } input = input.trim(); if (input.length() == 0) { return new byte[0]; } BigInteger resultNum = BigInteger.ZERO; int nLeadingZeros = 0; while (nLeadingZeros < input.length() && input.charAt(nLeadingZeros) == BASE58[0]) { nLeadingZeros++; } long acc = 0; int nDigits = 0; int p = nLeadingZeros; while (p < input.length()) { int v = BASE58_VALUES[input.charAt(p) & 0xff]; if (v >= 0) { acc *= 58; acc += v; nDigits++; if (nDigits == BASE58_CHUNK_DIGITS) { resultNum = resultNum.multiply(BASE58_CHUNK_MOD).add(BigInteger.valueOf(acc)); acc = 0; nDigits = 0; } p++; } else { break; } } if (nDigits > 0) { long mul = 58; while (--nDigits > 0) { mul *= 58; } resultNum = resultNum.multiply(BigInteger.valueOf(mul)).add(BigInteger.valueOf(acc)); } final int BASE58_SPACE = -2; while (p < input.length() && BASE58_VALUES[input.charAt(p) & 0xff] == BASE58_SPACE) { p++; } if (p < input.length()) { return null; } byte[] plainNumber = resultNum.toByteArray(); int plainNumbersOffs = plainNumber[0] == 0 ? 1 : 0; byte[] result = new byte[nLeadingZeros + plainNumber.length - plainNumbersOffs]; System.arraycopy(plainNumber, plainNumbersOffs, result, nLeadingZeros, plainNumber.length - plainNumbersOffs); return result; } public static String encode(byte[] input) { if (input == null) { return null; } StringBuilder str = new StringBuilder((input.length * 350) / 256 + 1); BigInteger bn = new BigInteger(1, input); long rem; while (true) { BigInteger[] divideAndRemainder = bn.divideAndRemainder(BASE58_CHUNK_MOD); bn = divideAndRemainder[0]; rem = divideAndRemainder[1].longValue(); if (bn.compareTo(BigInteger.ZERO) == 0) { break; } for (int i = 0; i < BASE58_CHUNK_DIGITS; i++) { str.append(BASE58[(int) (rem % 58)]); rem /= 58; } } while (rem != 0) { str.append(BASE58[(int) (rem % 58)]); rem /= 58; } str.reverse(); int nLeadingZeros = 0; while (nLeadingZeros < input.length && input[nLeadingZeros] == 0) { str.insert(0, BASE58[0]); nLeadingZeros++; } return str.toString(); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/Base58Check.java ================================================ /* * Bitcoin cryptography library * Copyright (c) Project Nayuki * * https://www.nayuki.io/page/bitcoin-cryptography-library * https://github.com/nayuki/Bitcoin-Cryptography-Library */ package com.quincysx.crypto.utils; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.math.BigInteger; import java.util.Arrays; /** * Converts between an array of bytes and a Base58Check string. Not instantiable. */ public final class Base58Check { /*---- Static functions ----*/ // Adds the checksum and converts to Base58Check. Note that the caller needs to prepend the version byte(s). public static String bytesToBase58(byte[] data) { return rawBytesToBase58(addCheckHash(data)); } // Directly converts to Base58Check without adding a checksum. static String rawBytesToBase58(byte[] data) { // Convert to base-58 string StringBuilder sb = new StringBuilder(); BigInteger num = new BigInteger(1, data); while (num.signum() != 0) { BigInteger[] quotrem = num.divideAndRemainder(ALPHABET_SIZE); sb.append(ALPHABET.charAt(quotrem[1].intValue())); num = quotrem[0]; } // Add '1' characters for leading 0-value bytes for (int i = 0; i < data.length && data[i] == 0; i++) sb.append(ALPHABET.charAt(0)); return sb.reverse().toString(); } // Returns a new byte array by concatenating the given array with its checksum. static byte[] addCheckHash(byte[] data) { try { byte[] hash = Arrays.copyOf(SHA256.doubleSha256(data), 4); ByteArrayOutputStream buf = new ByteArrayOutputStream(); buf.write(data); buf.write(hash); return buf.toByteArray(); } catch (IOException e) { throw new AssertionError(e); } } // Converts the given Base58Check string to a byte array, verifies the checksum, and removes the checksum to return the payload. // The caller is responsible for handling the version byte(s). public static byte[] base58ToBytes(String s) { byte[] concat = base58ToRawBytes(s); byte[] data = Arrays.copyOf(concat, concat.length - 4); byte[] hash = Arrays.copyOfRange(concat, concat.length - 4, concat.length); byte[] rehash = Arrays.copyOf(SHA256.doubleSha256(data), 4); if (!Arrays.equals(rehash, hash)) throw new IllegalArgumentException("Checksum mismatch"); return data; } // Converts the given Base58Check string to a byte array, without checking or removing the trailing 4-byte checksum. static byte[] base58ToRawBytes(String s) { // Parse base-58 string BigInteger num = BigInteger.ZERO; for (int i = 0; i < s.length(); i++) { num = num.multiply(ALPHABET_SIZE); int digit = ALPHABET.indexOf(s.charAt(i)); if (digit == -1) throw new IllegalArgumentException("Invalid character for Base58Check"); num = num.add(BigInteger.valueOf(digit)); } // Strip possible leading zero due to mandatory sign bit byte[] b = num.toByteArray(); if (b[0] == 0) b = Arrays.copyOfRange(b, 1, b.length); try { // Convert leading '1' characters to leading 0-value bytes ByteArrayOutputStream buf = new ByteArrayOutputStream(); for (int i = 0; i < s.length() && s.charAt(i) == ALPHABET.charAt(0); i++) buf.write(0); buf.write(b); return buf.toByteArray(); } catch (IOException e) { throw new AssertionError(e); } } /*---- Class constants ----*/ public static final String ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; // Everything except 0OIl private static final BigInteger ALPHABET_SIZE = BigInteger.valueOf(ALPHABET.length()); /*---- Miscellaneous ----*/ private Base58Check() { } // Not instantiable } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/Base64.java ================================================ package com.quincysx.crypto.utils; import org.spongycastle.util.Strings; import java.math.BigInteger; /** * @author QuincySx * @date 2018/3/1 下午5:59 */ public class Base64 { public static String decode(String input) { return Strings.fromByteArray(org.spongycastle.util.encoders.Base64.decode(input)); } public static String encode(BigInteger input) { return String.format("%064x", input); } public static String encode(byte[] input) { return Strings.fromByteArray(org.spongycastle.util.encoders.Base64.encode(input)); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/HexUtils.java ================================================ package com.quincysx.crypto.utils; /** * @author QuincySx * @date 2018/3/1 下午5:17 */ public final class HexUtils { public static String toHex(byte[] bytes) { if (bytes == null) { return ""; } final char[] hexArray = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; char[] hexChars = new char[bytes.length * 2]; int v; for (int j = 0; j < bytes.length; j++) { v = bytes[j] & 0xFF; hexChars[j * 2] = hexArray[v >>> 4]; hexChars[j * 2 + 1] = hexArray[v & 0x0F]; } return new String(hexChars); } public static byte[] fromHex(String s) { if (s != null) { try { StringBuilder sb = new StringBuilder(s.length()); for (int i = 0; i < s.length(); i++) { char ch = s.charAt(i); if (!Character.isWhitespace(ch)) { sb.append(ch); } } s = sb.toString(); int len = s.length(); byte[] data = new byte[len / 2]; for (int i = 0; i < len; i += 2) { int hi = (Character.digit(s.charAt(i), 16) << 4); int low = Character.digit(s.charAt(i + 1), 16); if (hi >= 256 || low < 0 || low >= 16) { return null; } data[i / 2] = (byte) (hi | low); } return data; } catch (Exception ignored) { } } return null; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/HmacSha512.java ================================================ /* * BIP32 library, a Java implementation of BIP32 * Copyright (C) 2017 Alan Evans, NovaCrypto * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program 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 General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Original source: https://github.com/NovaCrypto/BIP32 * You can contact the authors via github issues. */ package com.quincysx.crypto.utils; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; public final class HmacSha512 { private static final String HMAC_SHA512 = "HmacSHA512"; public static byte[] hmacSha512(final byte[] byteKey, final byte[] seed) { return initialize(byteKey) .doFinal(seed); } private static Mac initialize(final byte[] byteKey) { final Mac hmacSha512 = getInstance(HMAC_SHA512); final SecretKeySpec keySpec = new SecretKeySpec(byteKey, HMAC_SHA512); try { hmacSha512.init(keySpec); } catch (InvalidKeyException e) { e.printStackTrace(); } return hmacSha512; } private static Mac getInstance(final String HMAC_SHA256) { try { return Mac.getInstance(HMAC_SHA256); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return null; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/KECCAK256.java ================================================ package com.quincysx.crypto.utils; import org.spongycastle.crypto.digests.KeccakDigest; /** * @author QuincySx * @date 2018/3/2 上午11:12 */ public class KECCAK256 { private static final int keccak256_DIGEST_LENGTH = 32; public static byte[] keccak256(byte[] bytes) { return keccak256(bytes, 0, bytes.length); } public static byte[] keccak256(byte[] bytes, int offset, int size) { KeccakDigest keccakDigest = new KeccakDigest(256); keccakDigest.update(bytes, offset, size); byte[] keccak256 = new byte[keccak256_DIGEST_LENGTH]; // TODO: 2018/3/2 有 BUG keccakDigest.doFinal(keccak256, offset); return keccak256; } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/RIPEMD160.java ================================================ package com.quincysx.crypto.utils; import org.spongycastle.crypto.digests.RIPEMD160Digest; import org.spongycastle.crypto.digests.SHA256Digest; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; /** * @author QuincySx * @date 2018/3/1 下午5:00 */ public final class RIPEMD160 { private static final int RIPEMD160_DIGEST_LENGTH = 20; public static byte[] ripemd160(byte[] bytes) { RIPEMD160Digest ripemd160Digest = new RIPEMD160Digest(); ripemd160Digest.update(bytes, 0, bytes.length); byte[] hash160 = new byte[RIPEMD160_DIGEST_LENGTH]; ripemd160Digest.doFinal(hash160, 0); return hash160; } public static byte[] hash160(final byte[] bytes) { return ripemd160(SHA256.sha256(bytes)); } } ================================================ FILE: library/src/main/java/com/quincysx/crypto/utils/SHA256.java ================================================ package com.quincysx.crypto.utils; import android.util.Log; import org.spongycastle.crypto.digests.SHA256Digest; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; /** * @author QuincySx * @date 2018/3/1 下午4:58 */ public final class SHA256 { public static byte[] sha256(byte[] bytes) { return sha256(bytes, 0, bytes.length); } public static byte[] sha256(byte[] bytes, int offset, int size) { SHA256Digest sha256Digest = new SHA256Digest(); sha256Digest.update(bytes, offset, size); byte[] sha256 = new byte[32]; sha256Digest.doFinal(sha256, 0); return sha256; } public static byte[] doubleSha256(byte[] bytes) { return doubleSha256(bytes, 0, bytes.length); } public static byte[] doubleSha256(byte[] bytes, int offset, int size) { try { MessageDigest sha256 = MessageDigest.getInstance("SHA-256"); sha256.update(bytes, offset, size); return sha256.digest(sha256.digest()); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return null; } } ================================================ FILE: library/src/main/res/values/strings.xml ================================================ Library ================================================ FILE: library/src/test/java/com/quincysx/crypto/Bip32UnitTest.java ================================================ package com.quincysx.crypto; import com.quincysx.crypto.bip39.MnemonicGenerator; import com.quincysx.crypto.bip39.SeedCalculator; import com.quincysx.crypto.bip39.WordCount; import com.quincysx.crypto.bip39.wordlists.English; import org.junit.Test; import java.security.SecureRandom; import static org.junit.Assert.assertEquals; /** * @author QuincySx * @date 2018/3/2 下午5:29 */ public class Bip32UnitTest { @Test public void addition_isCorrect() throws Exception { assertEquals(4, 2 + 2); final StringBuilder sb = new StringBuilder(); } } ================================================ FILE: library/src/test/java/com/quincysx/crypto/Bip39UnitTest.java ================================================ package com.quincysx.crypto; import com.quincysx.crypto.bip39.MnemonicGenerator; import com.quincysx.crypto.bip39.MnemonicValidator; import com.quincysx.crypto.bip39.RandomSeed; import com.quincysx.crypto.bip39.SeedCalculator; import com.quincysx.crypto.bip39.WordCount; import com.quincysx.crypto.bip39.validation.InvalidChecksumException; import com.quincysx.crypto.bip39.validation.InvalidWordCountException; import com.quincysx.crypto.bip39.validation.UnexpectedWhiteSpaceException; import com.quincysx.crypto.bip39.validation.WordNotFoundException; import com.quincysx.crypto.bip39.wordlists.English; import com.quincysx.crypto.utils.HexUtils; import org.junit.Test; import java.security.SecureRandom; import java.util.ArrayList; import java.util.List; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; /** * Example local unit test, which will execute on the development machine (host). * * @see Testing documentation */ public class Bip39UnitTest { @Test public void addition_isCorrect() throws Exception { assertEquals(4, 2 + 2); } @Test public void mnemonic() { byte[] random = RandomSeed.random(WordCount.TWELVE); List mnemonic = new MnemonicGenerator(English.INSTANCE).createMnemonic(random); assertNotNull(mnemonic); } @Test public void mnemonicResetByThreeList() { List mnemonicWordsInAList = new ArrayList<>(); mnemonicWordsInAList.add("sponsor"); mnemonicWordsInAList.add("thrive"); mnemonicWordsInAList.add("twin"); byte[] seed = new SeedCalculator() .withWordsFromWordList(English.INSTANCE) .calculateSeed(mnemonicWordsInAList, ""); assertEquals(HexUtils.toHex(seed), "411b65ae261e383c5e3846e8290b693ae8a6c86aa55f87e946f940945f5e8476e722161351485c07fb6fe71229899d2565f114d4c84cf0dec714ee9dfb8f9bde"); } @Test public void mnemonicResetByList() { List mnemonicWordsInAList = new ArrayList<>(); mnemonicWordsInAList.add("cupboard"); mnemonicWordsInAList.add("shed"); mnemonicWordsInAList.add("accident"); mnemonicWordsInAList.add("simple"); mnemonicWordsInAList.add("marble"); mnemonicWordsInAList.add("drive"); mnemonicWordsInAList.add("put"); mnemonicWordsInAList.add("crew"); mnemonicWordsInAList.add("marine"); mnemonicWordsInAList.add("mistake"); mnemonicWordsInAList.add("shop"); mnemonicWordsInAList.add("chimney"); mnemonicWordsInAList.add("plate"); mnemonicWordsInAList.add("throw"); mnemonicWordsInAList.add("cable"); byte[] seed = new SeedCalculator() .withWordsFromWordList(English.INSTANCE) .calculateSeed(mnemonicWordsInAList, ""); byte[] seed1 = new SeedCalculator() .calculateSeed(mnemonicWordsInAList, ""); assertEquals(HexUtils.toHex(seed1), "165b063a8f7a58e3650534512f53ffeb2cdab1b73604ce631f5e340aa3ff266cb8811bd671ff6268d10bc64200ea671c94e35f413d130d3d9e7ee86b10021c54"); } } ================================================ FILE: library/src/test/java/com/quincysx/crypto/Bip44UnitTest.java ================================================ package com.quincysx.crypto; import org.junit.Test; import static org.junit.Assert.assertEquals; /** * @author QuincySx * @date 2018/3/2 下午5:29 */ public class Bip44UnitTest { @Test public void addition_isCorrect() throws Exception { assertEquals(4, 2 + 2); } } ================================================ FILE: library/src/test/java/com/quincysx/crypto/Eip55UnitTest.java ================================================ package com.quincysx.crypto; import android.util.Log; import com.quincysx.crypto.eip55.EthCheckAddress; import org.junit.Test; import static org.junit.Assert.assertEquals; /** * @author QuincySx * @date 2018/3/2 下午5:29 */ public class Eip55UnitTest { @Test public void addition_isCorrect() throws Exception { String s = EthCheckAddress.toChecksumAddress("0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb"); assertEquals(s, "0xD1220A0cf47c7B9Be7A2E6BA89F429762e7b9aDb"); String s1 = EthCheckAddress.toChecksumAddress("0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"); assertEquals(s1, "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed"); String s2 = EthCheckAddress.toChecksumAddress("0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359"); assertEquals(s2, "0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359"); String s3 = EthCheckAddress.toChecksumAddress("0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB"); assertEquals(s3, "0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB"); boolean check1 = EthCheckAddress.checksumAddress("0xdbF03B407c01E7cD3CBea99509d93f8DDDC8C6FB"); assertEquals(check1, true); boolean check2 = EthCheckAddress.checksumAddress("0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5D359"); assertEquals(check2, false); boolean check3 = EthCheckAddress.checksumAddress("0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359"); assertEquals(check3, true); boolean check4 = EthCheckAddress.checksumAddress("0xfb6916095ca1df60bb79ce92ce3ea74c37c5d359"); assertEquals(check4, true); boolean check5 = EthCheckAddress.checksumAddress("fb6916095ca1df60bb79ce92ce3ea74c37c5d359"); assertEquals(check5, false); } } ================================================ FILE: library/src/test/java/com/quincysx/crypto/ExampleUnitTest.java ================================================ package com.quincysx.crypto; import com.quincysx.crypto.utils.Base64; import com.quincysx.crypto.utils.HexUtils; import org.junit.Test; import java.math.BigInteger; import static org.junit.Assert.*; /** * Example local unit test, which will execute on the development machine (host). * * @see Testing documentation */ public class ExampleUnitTest { @Test public void addition_isCorrect() throws Exception { BigInteger bigInteger = new BigInteger("2222"); String s = Base64.encode(bigInteger); BigInteger bigInteger1 = new BigInteger(1,HexUtils.fromHex(s)); assertEquals(bigInteger, bigInteger1); } } ================================================ FILE: library/src/test/java/com/quincysx/crypto/HashUnitTest.java ================================================ package com.quincysx.crypto; import com.quincysx.crypto.utils.Base64; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.KECCAK256; import com.quincysx.crypto.utils.RIPEMD160; import com.quincysx.crypto.utils.SHA256; import org.junit.Test; import static org.junit.Assert.assertEquals; /** * Example local unit test, which will execute on the development machine (host). * * @see Testing documentation */ public class HashUnitTest { @Test public void addition_isCorrect() throws Exception { assertEquals(4, 2 + 2); } @Test public void testKeccak256() { byte[] bytes = KECCAK256.keccak256("12".getBytes()); assertEquals(HexUtils.toHex(bytes), "7f8b6b088b6d74c2852fc86c796dca07b44eed6fb3daf5e6b59f7c364db14528"); } @Test public void testSha256() { byte[] bytes = SHA256.sha256("12".getBytes()); assertEquals(HexUtils.toHex(bytes), "6b51d431df5d7f141cbececcf79edf3dd861c3b4069f0b11661a3eefacbba918"); byte[] bytes1 = SHA256.sha256("6b51d431df5d7f141cbececcf79edf3dd861c3b4069f0b11661a3eefacbba918".getBytes()); assertEquals(HexUtils.toHex(bytes1), "ab2e30bf75636a9c97e05099d9ccc9b623c17a44f629e7ce7206dba683028db1"); } @Test public void testDoubleSha256() { byte[] bytes = SHA256.doubleSha256("12".getBytes()); assertEquals(HexUtils.toHex(bytes), "ab2e30bf75636a9c97e05099d9ccc9b623c17a44f629e7ce7206dba683028db1"); } @Test public void testRipemd160() { byte[] bytes = RIPEMD160.ripemd160("12".getBytes()); assertEquals(HexUtils.toHex(bytes), "58bd2c615ce3fbfa69b1e0e309b610e40cb4c83f"); } @Test public void testHash160() { byte[] bytes = RIPEMD160.hash160("12".getBytes()); assertEquals(HexUtils.toHex(bytes), "02668db46b805753c3cb0aaa3129af37d026e309"); } @Test public void testBase64Encode() { String base64 = Base64.encode("58bd2c615ce3fbfa69b1e0e309b610e40cb4c83f".getBytes()); assertEquals(base64, "NThiZDJjNjE1Y2UzZmJmYTY5YjFlMGUzMDliNjEwZTQwY2I0YzgzZg=="); } @Test public void testBase64Decode() { String base64 = Base64.decode("NThiZDJjNjE1Y2UzZmJmYTY5YjFlMGUzMDliNjEwZTQwY2I0YzgzZg=="); assertEquals(base64, "58bd2c615ce3fbfa69b1e0e309b610e40cb4c83f"); } } ================================================ FILE: sample/.gitignore ================================================ /build ================================================ FILE: sample/build.gradle ================================================ apply plugin: 'com.android.application' android { compileSdkVersion 27 defaultConfig { applicationId "com.quincysx.crypto.smpale" minSdkVersion 15 targetSdkVersion 27 versionCode 1 versionName "1.0" testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner" } buildTypes { release { minifyEnabled false proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro' } } } dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) implementation 'com.android.support:appcompat-v7:27.1.0' implementation 'com.android.support.constraint:constraint-layout:1.0.2' testImplementation 'junit:junit:4.12' androidTestImplementation 'com.android.support.test:runner:1.0.1' androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1' implementation project(':library') } ================================================ FILE: sample/proguard-rules.pro ================================================ # Add project specific ProGuard rules here. # You can control the set of applied configuration files using the # proguardFiles setting in build.gradle. # # For more details, see # http://developer.android.com/guide/developing/tools/proguard.html # If your project uses WebView with JS, uncomment the following # and specify the fully qualified class name to the JavaScript interface # class: #-keepclassmembers class fqcn.of.javascript.interface.for.webview { # public *; #} # Uncomment this to preserve the line number information for # debugging stack traces. #-keepattributes SourceFile,LineNumberTable # If you keep the line number information, uncomment this to # hide the original source file name. #-renamesourcefileattribute SourceFile ================================================ FILE: sample/src/androidTest/java/com/quincysx/crypto/ExampleInstrumentedTest.java ================================================ package com.quincysx.crypto; import android.content.Context; import android.support.test.InstrumentationRegistry; import android.support.test.runner.AndroidJUnit4; import org.junit.Test; import org.junit.runner.RunWith; import static org.junit.Assert.*; /** * Instrumented test, which will execute on an Android device. * * @see Testing documentation */ @RunWith(AndroidJUnit4.class) public class ExampleInstrumentedTest { @Test public void useAppContext() throws Exception { // Context of the app under test. Context appContext = InstrumentationRegistry.getTargetContext(); assertEquals("com.quincysx.crypto", appContext.getPackageName()); } } ================================================ FILE: sample/src/main/AndroidManifest.xml ================================================ ================================================ FILE: sample/src/main/java/com/quincysx/crypto/smpale/Main1Activity.java ================================================ package com.quincysx.crypto.smpale; import android.os.Bundle; import android.support.v7.app.AppCompatActivity; import android.util.Log; import com.fasterxml.jackson.core.JsonParseException; import com.fasterxml.jackson.databind.JsonMappingException; import com.quincysx.crypto.CoinTypes; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.bip32.ExtendedKey; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.bip39.MnemonicGenerator; import com.quincysx.crypto.bip39.RandomSeed; import com.quincysx.crypto.bip39.SeedCalculator; import com.quincysx.crypto.bip39.WordCount; import com.quincysx.crypto.bip39.wordlists.English; import com.quincysx.crypto.bip44.AddressIndex; import com.quincysx.crypto.bip44.BIP44; import com.quincysx.crypto.bip44.CoinPairDerive; import com.quincysx.crypto.bitcoin.BTCTransaction; import com.quincysx.crypto.bitcoin.BitcoinException; import com.quincysx.crypto.eip55.EthCheckAddress; import com.quincysx.crypto.eos.EOSECKeyPair; import com.quincysx.crypto.ethereum.EthECKeyPair; import com.quincysx.crypto.ethereum.keystore.CipherException; import com.quincysx.crypto.ethereum.keystore.KeyStore; import com.quincysx.crypto.ethereum.keystore.KeyStoreFile; import com.quincysx.crypto.utils.HexUtils; import org.spongycastle.jcajce.provider.digest.SHA256; import org.spongycastle.util.encoders.Hex; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.math.BigInteger; import java.util.ArrayList; import java.util.List; public class Main1Activity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); List strings = new ArrayList<>(); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); strings.add("a"); byte[] seed = new SeedCalculator().calculateSeed(strings, ""); try { seed = com.quincysx.crypto.utils.SHA256.sha256("a a a a a a a a a a a a".getBytes("Utf-8")); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } // byte[] seed = new SeedCalculator().calculateSeed(strings, ""); // EOSECKeyPair eosecKeyPair = new EOSECKeyPair(ECKeyPair.createNew(true)); try { // EOSECKeyPair eosecKeyPair = EOSECKeyPair.parse("5JLwgEmaMivG4h4TH6T9WXMCerVU9SqTrrVm5g89idvG9CT4GUg"); //public EOS6iGwqWSuGK9JGNxbU1kM4DoadTAHNNcuAvJ1EyU5BUJy9u3dQa EOSECKeyPair eosecKeyPair = new EOSECKeyPair(seed); Log.e("=private=", eosecKeyPair.getPrivateKey()); Log.e("=public=", eosecKeyPair.getPublicKey()); } catch (ValidationException e) { e.printStackTrace(); } } } ================================================ FILE: sample/src/main/java/com/quincysx/crypto/smpale/MainActivity.java ================================================ package com.quincysx.crypto.smpale; import android.os.Bundle; import android.support.v7.app.AppCompatActivity; import android.util.Log; import com.fasterxml.jackson.core.JsonParseException; import com.fasterxml.jackson.databind.JsonMappingException; import com.quincysx.crypto.CoinTypes; import com.quincysx.crypto.ECKeyPair; import com.quincysx.crypto.bip32.ExtendedKey; import com.quincysx.crypto.bip32.ValidationException; import com.quincysx.crypto.bip39.MnemonicGenerator; import com.quincysx.crypto.bip39.MnemonicValidator; import com.quincysx.crypto.bip39.RandomSeed; import com.quincysx.crypto.bip39.SeedCalculator; import com.quincysx.crypto.bip39.WordCount; import com.quincysx.crypto.bip39.wordlists.English; import com.quincysx.crypto.bip44.AddressIndex; import com.quincysx.crypto.bip44.BIP44; import com.quincysx.crypto.bip44.CoinPairDerive; import com.quincysx.crypto.ethereum.EthECKeyPair; import com.quincysx.crypto.ethereum.keystore.CipherException; import com.quincysx.crypto.ethereum.keystore.KeyStore; import com.quincysx.crypto.ethereum.keystore.KeyStoreFile; import java.io.IOException; import java.math.BigInteger; import java.util.ArrayList; import java.util.List; public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // try { // long time1 = System.currentTimeMillis(); // BitCoinKeyPairGenerator generator = new BitCoinKeyPairGenerator(); // long time2 = System.currentTimeMillis(); // BitcoinKeyPair bitcoinKeyPair = generator.generateBitcoinKeyPair(true, false); // long time3 = System.currentTimeMillis(); // Log.e("===private===", bitcoinKeyPair.getPrivateKey()); // Log.e("===public===", bitcoinKeyPair.getPublicKey()); // Log.e("===address===", bitcoinKeyPair.getAddress()); // // Log.e("===时间1===", String.format("%d", time2 - time1)); // Log.e("===时间2===", String.format("%d", time3 - time2)); // } catch (InvalidAlgorithmParameterException e) { // e.printStackTrace(); // } catch (NoSuchAlgorithmException e) { // e.printStackTrace(); // } // try { // long time1 = System.currentTimeMillis(); // ETHKeyPairGenerator generator = new ETHKeyPairGenerator(); // long time2 = System.currentTimeMillis(); // ETHKeyPair ethKeyPair = generator.generateETHKeyPair(); // long time3 = System.currentTimeMillis(); // Log.e("===private===", ethKeyPair.getPrivateKey()); // Log.e("===public===", ethKeyPair.getPublicKey()); // Log.e("===address===", ethKeyPair.getAddress()); // // Log.e("===时间1===", String.format("%d", time2 - time1)); // Log.e("===时间2===", String.format("%d", time3 - time2)); // } catch (InvalidAlgorithmParameterException e) { // e.printStackTrace(); // } catch (NoSuchAlgorithmException e) { // e.printStackTrace(); // } final List mnemonicWordsInAList = new ArrayList<>(); // mnemonicWordsInAList.add("flavor"); // mnemonicWordsInAList.add("casual"); // mnemonicWordsInAList.add("library"); // mnemonicWordsInAList.add("knee"); // mnemonicWordsInAList.add("shy"); // mnemonicWordsInAList.add("erupt"); // mnemonicWordsInAList.add("wall"); // mnemonicWordsInAList.add("until"); // mnemonicWordsInAList.add("usual"); // mnemonicWordsInAList.add("bronze"); // mnemonicWordsInAList.add("scout"); // mnemonicWordsInAList.add("immune"); mnemonicWordsInAList.add("age"); mnemonicWordsInAList.add("jazz"); mnemonicWordsInAList.add("plunge"); mnemonicWordsInAList.add("quantum"); mnemonicWordsInAList.add("envelope"); mnemonicWordsInAList.add("crime"); mnemonicWordsInAList.add("dial"); mnemonicWordsInAList.add("foster"); mnemonicWordsInAList.add("lunch"); mnemonicWordsInAList.add("amazing"); mnemonicWordsInAList.add("athlete"); mnemonicWordsInAList.add("diet"); Log.e("=====", "===" + mnemonicWordsInAList.toString()); try { byte[] random = RandomSeed.random(WordCount.TWELVE); List strings = new MnemonicGenerator(English.INSTANCE).createMnemonic(random); byte[] seed = new SeedCalculator().calculateSeed(strings,""); // ExtendedKey extendedKey = ExtendedKey.create(seed); // AddressIndex address = BIP44.m().purpose44() // .coinType(1) // .account(0) // .external() // .address(0); // CoinPairDerive coinKeyPair = new CoinPairDerive(extendedKey); // ExtendedKey master = coinKeyPair.deriveByExtendedKey(address); // CoinKeyPair bitcoinKeyPair = coinKeyPair.convertEthKeyPair(new BigInteger(1, master // .getMaster().getPrivate())); Log.e("=1221=", "==========开始============"); ExtendedKey extendedKey = ExtendedKey.create(seed); AddressIndex address = BIP44.m().purpose44() .coinType(CoinTypes.Ethereum) .account(0) .external() .address(0); CoinPairDerive coinKeyPair = new CoinPairDerive(extendedKey); ECKeyPair master = coinKeyPair.derive(address); Log.e("=1221=", "==" + address.toString()); Log.e("=1221private", master.getPrivateKey()); Log.e("=1221public=", master.getPublicKey()); Log.e("=1221address=", master.getAddress()); Log.e("=1221=", "======================"); if (master instanceof EthECKeyPair) { try { KeyStoreFile light = KeyStore.createLight("123456", (EthECKeyPair) master); Log.e("======", light.toString()); } catch (CipherException e) { e.printStackTrace(); } } KeyStoreFile keyStoreFile = KeyStoreFile.parse("{\"address\":\"cafee4583441d2682bea06b6e8bfa722a7cea848\"," + "\"id\":\"1562c4fe-c714-4187-ad62-6baff33e3633\",\"version\":3," + "\"crypto\":{\"cipher\":\"aes-128-ctr\"," + "\"cipherparams\":{\"iv\":\"e0ba8a361141cc01f6860170ab8ee25c\"}," + "\"ciphertext\":\"4ee617421d4283c706c2bd48f43739d58b4aede740b62208f78cd33427419062\",\"kdf\":\"scrypt\",\"kdfparams\":{\"dklen\":32,\"n\":4096,\"p\":6,\"r\":8,\"salt\":\"85aab20aa7398f4dc0cde887c3b44c5d0ac2a5419dd6eb026272cccc55dc2588\"},\"mac\":\"29dd9c95c69611926cc826df68d65899fe11f18990d3dac7ba3778980e5a45ec\"}}"); try { ECKeyPair decrypt = KeyStore.decrypt("123456", keyStoreFile); Log.e("=12321=", "==" + decrypt.toString()); Log.e("=12321private", decrypt.getPrivateKey()); Log.e("=12321public=", decrypt.getPublicKey()); Log.e("=12321address=", decrypt.getAddress()); Log.e("=12321=", "======================"); } catch (CipherException e) { e.printStackTrace(); } // try { // BTCTransaction btcTransaction = new BTCTransaction(HexUtils.fromHex // // ("02000000018aad5febb0f5165097727eb402d15e96c615560b6d4e0fcbee0882ff589af3220000000000ffffffff0240420f00000000001976a91438ae48c4ff53e9ba952d3c63f200f2dfe04f330188aca0cd8700000000001976a91481f9f80df4efb08e373fa8f2b8896f33e3a270f388ac00000000")); // byte[] sign = btcTransaction.sign(master); // Log.e("===", HexUtils.toHex(sign)); // } catch (BitcoinException e) { // e.printStackTrace(); // } // Log.e("=====", "================================================sdasdasdasd"); // BitCoinECKeyPair bitCoinECKeyPair = BitCoinECKeyPair.parseWIF(master.getPrivateKey()); // Log.e("=====", "================================================sdasdasdasd"); // // Log.e("=1221private", bitCoinECKeyPair.getPrivateKey()); // Log.e("=1221public=", bitCoinECKeyPair.getPublicKey()); // Log.e("=1221address=", bitCoinECKeyPair.getAddress()); // Log.e("=1221=", "======================"); // if (master instanceof BitCoinECKeyPair) { // try { // String s = Bip38.encryptNoEcMultiply("123456", master // .getPrivateKey()); // Log.e("=====", s); // BitCoinECKeyPair s1 = Bip38.decrypt(s, "123456"); // // Log.e("=====", s1.getPrivateKey()); // } catch (InterruptedException e) { // e.printStackTrace(); // } // } //普通上链签名========= BigInteger nonce = new BigInteger("12"); BigInteger gasLimit = new BigInteger("1500000"); // BigInteger gasLimit = new BigInteger("21000"); BigInteger gasPrice = new BigInteger("5000000000"); // BigInteger gasPrice = new BigInteger("0"); // // EthTransaction ethTransaction = EthTransaction // .create("cAfEE4583441D2682bEa06b6E8bFA722a7cea848", // new BigInteger("10000000000000000"), // nonce, // gasPrice, // gasLimit, 3); // ethTransaction.sign((ECKeyPair) master.getMaster()); // // byte[] rawHash = ethTransaction.getEncoded(); // // Log.e("====签名===", HexUtils.toHex(rawHash)); //调用合约查余额==== // CallTransaction.Function function = CallTransaction.Function // .fromSignature("balanceOf", "address"); // byte[] data = function.encode("cAfEE4583441D2682bEa06b6E8bFA722a7cea848"); // // Log.e("====合约===", HexUtils.toHex(data)); //转 Token // Transaction txConst = CallTransaction.createCallTransaction(nonce, // gasPrice, gasLimit, // "6b3b3386f46d2872a4bbfda001cebc7dec844593", new BigInteger("0"), // CallTransaction.Function.fromSignature("transfer", // "address", "uint256"), "4de1f8192dc059cc15f7ba2a045082263cfd1644", // new BigInteger("100000000000000000")); // // txConst.sign(master); // byte[] data = txConst.getData(); // byte[] rawHash = txConst.getSignBytes(); // // Log.e("====转Token合约参数===", HexUtils.toHex(data)); // Log.e("====转Token签名===", HexUtils.toHex(rawHash)); } catch (ValidationException e) { e.printStackTrace(); } catch (JsonParseException e) { e.printStackTrace(); } catch (JsonMappingException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } // String s = BIP44.m() // .purpose44() // .coinType(CoinTypes.Ethereum) // .account(0) // .external() // .address(1, true).toString(); // Log.e("=====", "address1 " + s); // try { // AddressIndex addressIndex = BIP44.parsePath(s); // String s1 = addressIndex.toString(); // Log.e("=====", "address2 " + s1); // } catch (NonSupportException e) { // e.printStackTrace(); // } catch (CoinNotFindException e) { // e.printStackTrace(); // } } } ================================================ FILE: sample/src/main/res/drawable/ic_launcher_background.xml ================================================ ================================================ FILE: sample/src/main/res/drawable-v24/ic_launcher_foreground.xml ================================================ ================================================ FILE: sample/src/main/res/layout/activity_main.xml ================================================ ================================================ FILE: sample/src/main/res/mipmap-anydpi-v26/ic_launcher.xml ================================================ ================================================ FILE: sample/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml ================================================ ================================================ FILE: sample/src/main/res/values/colors.xml ================================================ #3F51B5 #303F9F #FF4081 ================================================ FILE: sample/src/main/res/values/strings.xml ================================================ CryptoDemo ================================================ FILE: sample/src/main/res/values/styles.xml ================================================ ================================================ FILE: sample/src/test/java/com/quincysx/crypto/ExampleUnitTest.java ================================================ package com.quincysx.crypto; import com.quincysx.crypto.utils.Base64; import com.quincysx.crypto.utils.HexUtils; import com.quincysx.crypto.utils.KECCAK256; import com.quincysx.crypto.utils.RIPEMD160; import com.quincysx.crypto.utils.SHA256; import org.junit.Test; import org.spongycastle.util.Strings; import static org.junit.Assert.*; /** * Example local unit test, which will execute on the development machine (host). * * @see Testing documentation */ public class ExampleUnitTest { @Test public void addition_isCorrect() throws Exception { assertEquals(4, 2 + 2); } } ================================================ FILE: settings.gradle ================================================ include ':sample', ':library'