pax_global_header00006660000000000000000000000064140664105520014515gustar00rootroot0000000000000052 comment=5962c83067e0617f83e1bb462bccb1573a6c09d2 crypto-java-crypto-java-1.8.0/000077500000000000000000000000001406641055200162175ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/.github/000077500000000000000000000000001406641055200175575ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/.github/workflows/000077500000000000000000000000001406641055200216145ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/.github/workflows/ci.yml000066400000000000000000000017631406641055200227410ustar00rootroot00000000000000name: CI on: push: branches: - main pull_request: jobs: build: name: Build and Test strategy: fail-fast: false matrix: os: [ubuntu-latest, macos-latest, windows-latest] jdk: [1.8, 9, 11, 15] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v2 - name: Set up JDK uses: actions/setup-java@v1 with: java-version: ${{ matrix.jdk }} - name: Cache Maven packages uses: actions/cache@v2 with: path: ~/.m2 key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }} restore-keys: ${{ runner.os }}-m2 - name: Maven Build run: mvn -V -B -DskipTests=true install - name: Maven Test run: mvn -B verify # - name: Maven Code Coverage # if: ${{ github.ref == 'refs/heads/main' && matrix.jdk == '1.8' && matrix.os == 'ubuntu-latest' }} # run: mvn -B jacoco:report coveralls:report -DrepoToken=${{ secrets.COVERALLS_TOKEN }}crypto-java-crypto-java-1.8.0/.gitignore000077500000000000000000000000641406641055200202120ustar00rootroot00000000000000target/ *.iml .idea/ .project .classpath .settings/ crypto-java-crypto-java-1.8.0/LGPL2.1-template.txt000077500000000000000000000014261406641055200215560ustar00rootroot00000000000000${project.name} ${project.description} Copyright (C) ${project.inceptionYear} ${organization} This 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 2.1 of the License, or (at your option) any later version. This 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 this library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USAcrypto-java-crypto-java-1.8.0/LICENSE000077500000000000000000000635031406641055200172360ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1, February 1999 Copyright (C) 1991, 1999 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the Lesser GPL. It also counts as the successor of the GNU Library Public License, version 2, hence the version number 2.1.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Lesser General Public License, applies to some specially designated software packages--typically libraries--of the Free Software Foundation and other authors who decide to use it. You can use it too, but we suggest you first think carefully about whether this license or the ordinary General Public License is the better strategy to use in any particular case, based on the explanations below. When we speak of free software, we are referring to freedom of use, 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 this service if you wish); that you receive source code or can get it if you want it; that you can change the software and use pieces of it in new free programs; and that you are informed that you can do these things. To protect your rights, we need to make restrictions that forbid distributors to deny you these rights or to ask you to surrender these rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link other code with the library, you must provide complete object files to the recipients, so that they can relink them with the library after making changes to the library and recompiling it. And you must show them these terms so they know their rights. We protect your rights with a two-step method: (1) we copyright the library, and (2) we offer you this license, which gives you legal permission to copy, distribute and/or modify the library. To protect each distributor, we want to make it very clear that there is no warranty for the free library. Also, if the library is modified by someone else and passed on, the recipients should know that what they have is not the original version, so that the original author's reputation will not be affected by problems that might be introduced by others. Finally, software patents pose a constant threat to the existence of any free program. We wish to make sure that a company cannot effectively restrict the users of a free program by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent license obtained for a version of the library must be consistent with the full freedom of use specified in this license. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License. This license, the GNU Lesser General Public License, applies to certain designated libraries, and is quite different from the ordinary General Public License. We use this license for certain libraries in order to permit linking those libraries into non-free programs. When a program is linked with a library, whether statically or using a shared library, the combination of the two is legally speaking a combined work, a derivative of the original library. The ordinary General Public License therefore permits such linking only if the entire combination fits its criteria of freedom. The Lesser General Public License permits more lax criteria for linking other code with the library. We call this license the "Lesser" General Public License because it does Less to protect the user's freedom than the ordinary General Public License. It also provides other free software developers Less of an advantage over competing non-free programs. These disadvantages are the reason we use the ordinary General Public License for many libraries. However, the Lesser license provides advantages in certain special circumstances. For example, on rare occasions, there may be a special need to encourage the widest possible use of a certain library, so that it becomes a de-facto standard. To achieve this, non-free programs must be allowed to use the library. A more frequent case is that a free library does the same job as widely used non-free libraries. In this case, there is little to gain by limiting the free library to free software only, so we use the Lesser General Public License. In other cases, permission to use a particular library in non-free programs enables a greater number of people to use a large body of free software. For example, permission to use the GNU C Library in non-free programs enables many more people to use the whole GNU operating system, as well as its variant, the GNU/Linux operating system. Although the Lesser General Public License is Less protective of the users' freedom, it does ensure that the user of a program that is linked with the Library has the freedom and the wherewithal to run that program using a modified version of the Library. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, whereas the latter must be combined with the library in order to run. GNU LESSER GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library or other program which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Lesser General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also combine or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (1) uses at run time a copy of the library already present on the user's computer system, rather than copying library functions into the executable, and (2) will operate properly with a modified version of the library, if the user installs one, as long as the modified version is interface-compatible with the version that the work was made with. c) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. d) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. e) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the materials to be distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties with this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), 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 distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Lesser 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 Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "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 LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY 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 LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey 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 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 2.1 of the License, or (at your option) any later version. This 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 this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! crypto-java-crypto-java-1.8.0/README.md000077500000000000000000000017111406641055200175010ustar00rootroot00000000000000[![CI](https://github.com/expath/crypto-java/workflows/CI/badge.svg)](https://github.com/expath/crypto-java/actions?query=workflow%3ACI) [![Java 8+](https://img.shields.io/badge/java-8%2B-blue.svg)](https://adoptopenjdk.net/) [![License](https://img.shields.io/badge/license-LGPL%202.1-blue.svg)](https://opensource.org/licenses/lgpl-2.1) [![Maven Central](https://img.shields.io/maven-central/v/org.expath.crypto/crypto-java.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22org.expath.crypto%22%20AND%20a:%22crypto-java%22) # Java library for EXPath Crypto Module This is a Java implementation of the [EXPath HTTP Crypto Module specification](http://expath.org/spec/crypto). We provide a Java library that may be used as the basis for specific product implementations. # Building from source Requires: * Java 1.8 or newer * Maven 3.6 or newer ```bash $ git clone https://github.com/expath/crypto-java.git $ cd crypto-java $ mvn clean package ```crypto-java-crypto-java-1.8.0/pom.xml000077500000000000000000000222021406641055200175350ustar00rootroot00000000000000 4.0.0 org.expath expath-parent 1.5.0 org.expath.crypto crypto-java 1.8.0 jar EXPath Cryptographic Module Java Library providing an EXPath Cryptographic Module scm:git:https://github.com/expath/crypto-java.git scm:git:https://github.com/expath/crypto-java.git scm:git:https://github.com/expath/crypto-java.git crypto-java-1.8.0 https://github.com/expath/crypto-java 2015 GNU Lesser General Public License version 2.1 https://opensource.org/licenses/LGPL-2.1 repo claudius Claudius Teodorescu Kuberam claudius.teodorescu@gmail.com http://kuberam.ro Adam Retter Evolved Binary adam@evolvedbinary.com https://www.evolvedbinary.com 3.6.0 org.slf4j slf4j-api com.google.code.findbugs jsr305 jakarta.xml.bind jakarta.xml.bind-api 3.0.1 ch.qos.logback logback-classic 1.2.3 test junit junit test com.fasterxml.uuid java-uuid-generator 4.0.1 test commons-io commons-io 2.10.0 test org.apache.maven.plugins maven-enforcer-plugin 3.0.0-M3 enforce-maven enforce ${maven.version} org.apache.maven.plugins maven-dependency-plugin 3.1.2 com.mycila license-maven-plugin 4.1 true true false
LGPL2.1-template.txt
${project.organization.name} Kuberam ${project.organization.url} .github/** README.md LICENSE src/main/resources/changelog.txt src/main/resources/ro/kuberam/libs/java/crypto/lib.properties src/test/resources/**/*.txt src/test/resources/**/*.xml **/*.cer **/*.ks **/*.key **/*.pub **/*.pkcs8 pom.xml src/test/java/ro/kuberam/libs/java/crypto/TestUtils.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashBinaryWithWrongAlgorithmTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashLargeBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashLargeStringTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashStringTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashStringWithWrongAlgorithmTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACLargeBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACLargeStringTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACStringTest.java
LGPL2.1-template.txt
${project.organization.name} ${project.organization.name} ${project.organization.url} pom.xml src/test/java/ro/kuberam/libs/java/crypto/TestUtils.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashBinaryWithWrongAlgorithmTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashLargeBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashLargeStringTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashStringTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HashStringWithWrongAlgorithmTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACLargeBinaryTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACLargeStringTest.java src/test/java/ro/kuberam/libs/java/crypto/digest/HMACStringTest.java org.apache.maven.plugins maven-site-plugin 3.9.1 org.apache.maven.plugins maven-project-info-reports-plugin 3.1.2 false org.apache.maven.plugins maven-surefire-report-plugin 3.0.0-M5 clojars.org https://clojars.org/repo crypto-java-crypto-java-1.8.0/src/000077500000000000000000000000001406641055200170065ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/000077500000000000000000000000001406641055200177325ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/000077500000000000000000000000001406641055200206535ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/000077500000000000000000000000001406641055200212735ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/000077500000000000000000000000001406641055200227215ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/000077500000000000000000000000001406641055200236525ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/000077500000000000000000000000001406641055200245735ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/000077500000000000000000000000001406641055200261135ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/CryptoError.java000077500000000000000000000056441406641055200312640ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; public enum CryptoError { NoSuchAlgorithmException("crypto:unknown-algorithm", "The specified algorithm is not supported."), SIGNATURE_TYPE("crypto:signature-type", "The specified signature type is not supported."), UNREADABLE_KEYSTORE("crypto:unreadable-keystore", "I/O error while reading keystore, or the password is incorrect."), DENIED_KEYSTORE("crypto:denied-keystore", "Permission denied to read keystore."), KEYSTORE_URL("crypto:keystore-url", "The keystore URL is invalid."), KeyStoreException("crypto:keystore-type", "The keystore type is not supported."), ALIAS_KEY("crypto:alias-key", "Cannot find key for alias in given keystore."), SIGNATURE_ELEMENT("crypto:signature-element", "Cannot find Signature element."), NoSuchPaddingException("crypto:inexistent-padding", "No such padding."), BadPaddingException("crypto:incorrect-padding", "Incorrect padding."), ENCRYPTION_TYPE("crypto:encryption-type", "The encryption type is not supported."), InvalidKeySpecException("crypto:invalid-crypto-key", "The cryptographic key is invalid."), InvalidKeyException("crypto:invalid-crypto-key", "The cryptographic key is invalid."), IllegalBlockSizeException("crypto:block-size", "Illegal block size."), DECRYPTION_TYPE("crypto:decryption-type", "The decryption type is not supported."), NoSuchProviderException("crypto:no-provider", "The provider is not set."), INPUT_RESOURCES("crypto.input-resources", "The 'enveloped' and 'enveloping' signatures have to be applied to only one resource."), INCORRECT_INITIALIZATION_VECTOR("crypto:incorrect-initialization-vector", "The initialization vector is not correct"); private String code; private String message; CryptoError(String code, String message) { this.code = code; this.message = message; } public String getCode() { return this.code; } public String getMessage() { return this.message; } public String getDescription() { return this.code + ", " + this.message; } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/CryptoException.java000077500000000000000000000031301406641055200321150ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; public class CryptoException extends Exception { /** * */ private static final long serialVersionUID = -2606956271206243301L; private CryptoError cryptoError; public CryptoException(CryptoError cryptoError) { super(cryptoError.getDescription()); this.cryptoError = cryptoError; } public CryptoException(CryptoError cryptoError, Throwable cause) { super(cryptoError.getDescription(), cause); this.cryptoError = cryptoError; } public static CryptoException fromCause(final Throwable cause) { final CryptoError cryptoError = CryptoError.valueOf(cause.getClass().getSimpleName()); return new CryptoException(cryptoError, cause); } public CryptoError getCryptoError() { return cryptoError; } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/ExpathCryptoModule.java000077500000000000000000000100331406641055200325560ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import java.io.InputStream; import java.util.HashMap; import java.util.Map; import java.util.Properties; /** * Implements the module definition. * * @author Claudius Teodorescu */ public class ExpathCryptoModule { // static { // java.security.Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); // } // // public final static Provider defaultProvider = java.security.Security.getProvider("BC"); public static final Properties libProperties = new Properties(); static { try (final InputStream propertiesIs = ExpathCryptoModule.class.getResourceAsStream("lib.properties")) { libProperties.load(propertiesIs); } catch (Exception e) { e.printStackTrace(); } } public static final String NAMESPACE_URI = "http://expath.org/ns/crypto"; public static final String PREFIX = "crypto"; public static final String VERSION = libProperties.getProperty("lib-version"); public static final String MODULE_DESCRIPTION = "A module for providing cryptographic services."; public static final String MODULE_NAME = "EXPath Cryptographic"; public static final Map javaStandardAlgorithmNames = new HashMap<>(); static { javaStandardAlgorithmNames.put("HMAC-MD5", "HmacMD5"); javaStandardAlgorithmNames.put("HMAC-SHA-1", "HmacSHA1"); javaStandardAlgorithmNames.put("HMAC-SHA-256", "HmacSHA256"); javaStandardAlgorithmNames.put("HMAC-SHA-384", "HmacSHA384"); javaStandardAlgorithmNames.put("HMAC-SHA-512", "HmacSHA512"); } // crypto:generate-signature() description public static final String canonicalization_algorithm = "The canonicalization algorithm applied to the SignedInfo element prior to performing signature calculations. Possible values are: 'exclusive', 'exclusive-with-comments', 'inclusive', and 'inclusive-with-comments'. The default value is 'inclusive-with-comments'."; public static final String DIGEST_ALGORITHM = "The digest algorithm to be applied to the signed object. Possible values are: 'SHA1', 'SHA256', and 'SHA512'. The default value is 'SHA1'."; public static final String SIGNATURE_ALGORITHM = "The algorithm used for signature generation and validation. Possible values are: 'DSA_SHA1', and 'RSA_SHA1'. The default value is 'RSA_SHA1'."; public static final String SIGNATURE_TYPE = "The method used for signing the content of signature. Possible values are: 'enveloping', 'enveloped', and 'detached'. The default value is 'enveloped'."; public static final String digitalCertificateDetailsDescription = "Details about the digital certificate to be used for signing the input document or document subset." + " The structure of this parameter is as follows (this is an example): " + "" + "JKS" + "ab987c" + "eXist" + "kpi135" + "/db/mykeystoreEXist.ks" + "."; }crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/ModuleDescription.java000077500000000000000000000024741406641055200324210ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; /** * Module description. * * @author Claudius Teodorescu */ public class ModuleDescription { public static final String VERSION = "1.1"; public static final String NAMESPACE_URI = ""; public static final String PREFIX = ""; public static final String MODULE_NAME = "Library for EXPath Cryptographic Module"; public static final String MODULE_DESCRIPTION = "A "; } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/Parameters.java000077500000000000000000000115451406641055200310720ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import javax.xml.crypto.dsig.CanonicalizationMethod; import javax.xml.crypto.dsig.DigestMethod; import javax.xml.crypto.dsig.SignatureMethod; import javax.xml.crypto.dsig.Transform; public class Parameters { private String canonicalizationAlgorithm = CanonicalizationMethod.INCLUSIVE_WITH_COMMENTS; private static String[] CANONICALIZATION_ALGORITHM_VALUES = {"exclusive", "exclusive-with-comments", "inclusive", "inclusive-with-comments"}; private String digestAlgorithm = DigestMethod.SHA1; private static String[] DIGEST_ALGORITHM_VALUES = {"SHA1", "SHA256", "SHA512"}; private String signatureAlgorithm = SignatureMethod.RSA_SHA1; private static String[] SIGNATURE_ALGORITHM_VALUES = {"DSA_SHA1", "RSA_SHA1"}; private String signatureNamespacePrefix = "dsig"; private String signatureType = "enveloped"; private static String[] SIGNATURE_TYPE_VALUES = {"enveloping", "enveloped", "detached"}; public String getCanonicalizationAlgorithm() { return canonicalizationAlgorithm; } public void setCanonicalizationAlgorithm(final String canonicalizationAlgorithm) throws CryptoException { if (!contains(CANONICALIZATION_ALGORITHM_VALUES, canonicalizationAlgorithm)) { throw new CryptoException(CryptoError.NoSuchAlgorithmException); } if (canonicalizationAlgorithm.equals("exclusive")) { this.canonicalizationAlgorithm = CanonicalizationMethod.EXCLUSIVE; } else if (canonicalizationAlgorithm.equals("exclusive-with-comments")) { this.canonicalizationAlgorithm = CanonicalizationMethod.EXCLUSIVE_WITH_COMMENTS; } else if (canonicalizationAlgorithm.equals("inclusive")) { this.canonicalizationAlgorithm = CanonicalizationMethod.INCLUSIVE; } this.canonicalizationAlgorithm = canonicalizationAlgorithm; } public String getDigestAlgorithm() { return digestAlgorithm; } public void setDigestAlgorithm(final String digestAlgorithm) throws CryptoException { if (!contains(DIGEST_ALGORITHM_VALUES, digestAlgorithm)) { throw new CryptoException(CryptoError.NoSuchAlgorithmException); } if (digestAlgorithm.equals("SHA256")) { this.digestAlgorithm = DigestMethod.SHA256; } else if (digestAlgorithm.equals("SHA512")) { this.digestAlgorithm = DigestMethod.SHA512; } else { this.digestAlgorithm = digestAlgorithm; } } public String getSignatureAlgorithm() { return signatureAlgorithm; } public void setSignatureAlgorithm(final String signatureAlgorithm) throws CryptoException { if (!contains(SIGNATURE_ALGORITHM_VALUES, signatureAlgorithm)) { throw new CryptoException(CryptoError.NoSuchAlgorithmException); } if (signatureAlgorithm.equals("DSA_SHA1")) { this.signatureAlgorithm = SignatureMethod.DSA_SHA1; } else { this.signatureAlgorithm = signatureAlgorithm; } } public String getSignatureNamespacePrefix() { return signatureNamespacePrefix; } public void setSignatureNamespacePrefix(final String signatureNamespacePrefix) { this.signatureNamespacePrefix = signatureNamespacePrefix; } public String getSignatureType() { System.out.println("signatureType = " + Transform.ENVELOPED); return signatureType; } public void setSignatureType(final String signatureType) { for (String e : SIGNATURE_TYPE_VALUES) { System.out.println("SIGNATURE_TYPE_VALUES = " + e); } if (!SIGNATURE_TYPE_VALUES.equals(signatureType)) { //throw new Exception(ErrorMessages.error_signatureType); } this.signatureType = signatureType; } private boolean contains(final String[] strs, final String str) { for (final String s : strs) { if (s.equals(str)) { return true; } } return false; } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/certificates/000077500000000000000000000000001406641055200305605ustar00rootroot00000000000000ConstructCertificationPath.java000077500000000000000000000027441406641055200366630ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/certificates/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.certificates; import java.security.cert.CertPath; import java.security.cert.Certificate; import java.security.cert.CertificateException; import java.security.cert.CertificateFactory; import java.util.Arrays; public class ConstructCertificationPath { public static CertPath run(Certificate[] certs) { try { CertificateFactory certFact = CertificateFactory.getInstance("X.509"); CertPath path = certFact.generateCertPath(Arrays.asList(certs)); return path; } catch (CertificateException e) { } return null; } } GenerateCertificate.java000077500000000000000000000233201406641055200352440ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/certificates/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.certificates; public class GenerateCertificate { // public static void main(String[] args) throws Exception { // String keystoreFile = "keyStoreFile.bin"; // String caAlias = "caAlias"; // String certToSignAlias = "cert"; // String newAlias = "newAlias"; // // char[] password = new char[]{'a','b','c','d','e','f','g','h'}; // char[] caPassword = new char[]{'a','b','c','d','e','f','g','h'}; // char[] certPassword = new char[]{'a','b','c','d','e','f','g','h'}; // // FileInputStream input = new FileInputStream(keystoreFile); // KeyStore keyStore = KeyStore.getInstance("JKS"); // keyStore.load(input, password); // input.close(); // // PrivateKey caPrivateKey = (PrivateKey) keyStore.getKey(caAlias, caPassword); // java.security.cert.Certificate caCert = keyStore.getCertificate(caAlias); // // byte[] encoded = caCert.getEncoded(); // X509CertImpl caCertImpl = new X509CertImpl(encoded); // // X509CertInfo caCertInfo = (X509CertInfo) caCertImpl.get(X509CertImpl.NAME + "." // + X509CertImpl.INFO); // // X500Name issuer = (X500Name) caCertInfo.get(X509CertInfo.SUBJECT + "." // + CertificateIssuerName.DN_NAME); // // java.security.cert.Certificate cert = keyStore.getCertificate(certToSignAlias); // PrivateKey privateKey = (PrivateKey) keyStore.getKey(certToSignAlias, certPassword); // encoded = cert.getEncoded(); // X509CertImpl certImpl = new X509CertImpl(encoded); // X509CertInfo certInfo = (X509CertInfo) certImpl // .get(X509CertImpl.NAME + "." + X509CertImpl.INFO); // // Date firstDate = new Date(); // Date lastDate = new Date(firstDate.getTime() + 365 * 24 * 60 * 60 * 1000L); // CertificateValidity interval = new CertificateValidity(firstDate, lastDate); // // certInfo.set(X509CertInfo.VALIDITY, interval); // // certInfo.set(X509CertInfo.SERIAL_NUMBER, new CertificateSerialNumber( // (int) (firstDate.getTime() / 1000))); // // certInfo.set(X509CertInfo.ISSUER + "." + CertificateSubjectName.DN_NAME, issuer); // // AlgorithmId algorithm = new AlgorithmId(AlgorithmId.md5WithRSAEncryption_oid); // certInfo.set(CertificateAlgorithmId.NAME + "." + CertificateAlgorithmId.ALGORITHM, algorithm); // X509CertImpl newCert = new X509CertImpl(certInfo); // // newCert.sign(caPrivateKey, "MD5WithRSA"); // // keyStore.setKeyEntry(newAlias, privateKey, certPassword, // new java.security.cert.Certificate[] { newCert }); // // FileOutputStream output = new FileOutputStream(keystoreFile); // keyStore.store(output, password); // output.close(); // // } // public static X509Certificate generateV1Certificate(KeyPair pair) // throws InvalidKeyException, NoSuchProviderException, SignatureException, CertificateEncodingException, IllegalStateException, NoSuchAlgorithmException // { // Security.addProvider(new BouncyCastleProvider()); // // generate the certificate // X509V1CertificateGenerator certGen = new X509V1CertificateGenerator(); // // // certGen.setSerialNumber(BigInteger.valueOf(System.currentTimeMillis())); // certGen.setIssuerDN(new X500Principal("CN=Test Certificate")); // certGen.setNotBefore(new Date(System.currentTimeMillis() - 50000)); // certGen.setNotAfter(new Date(System.currentTimeMillis() + 50000)); // certGen.setSubjectDN(new X500Principal("CN=Test Certificate")); // certGen.setPublicKey(pair.getPublic()); // certGen.setSignatureAlgorithm("SHA256WithRSAEncryption"); // // return certGen.generate(pair.getPrivate(), "BC"); // } // // public static KeyPair generateRSAKeyPair() throws Exception { // KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA", "BC"); // kpGen.initialize(1024, new SecureRandom()); // return kpGen.generateKeyPair(); // } // // public static void main( String[] args) throws Exception { // // Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); // // KeyPair pair = generateRSAKeyPair(); // // // generate the certificate // X509Certificate cert = generateV1Certificate(pair); // // // show some basic validation // cert.checkValidity(new Date()); // // cert.verify(cert.getPublicKey()); // // //System.out.println("Certificate for: " + cert ); // // byte[] buf = cert.getEncoded(); // FileOutputStream os = new FileOutputStream("mycert.cer"); // Writer wr = new OutputStreamWriter(os, StandardCharsets.UTF_8); // wr.write("-----BEGIN CERTIFICATE-----\n"); // wr.write(Base64.encodeToString( buf, true )); // wr.write("\n-----END CERTIFICATE-----\n"); // wr.flush(); // os.close(); // // //get certificate from fileC:\working // CertificateFactory x509CertFact = CertificateFactory.getInstance("X.509"); // FileInputStream fis = new FileInputStream("mycert.cer"); // X509Certificate certRetrieved = (X509Certificate) x509CertFact.generateCertificate(fis); // fis.close(); // // System.out.println(pair.getPrivate()); // // } /* Creating a Self-Signed Version 3 Certificate import java.math.BigInteger; import java.security.InvalidKeyException; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchProviderException; import java.security.SecureRandom; import java.security.Security; import java.security.SignatureException; import java.security.cert.X509Certificate; import java.util.Date; import javax.security.auth.x500.X500Principal; import org.bouncycastle.asn1.x509.BasicConstraints; import org.bouncycastle.asn1.x509.ExtendedKeyUsage; import org.bouncycastle.asn1.x509.GeneralName; import org.bouncycastle.asn1.x509.GeneralNames; import org.bouncycastle.asn1.x509.KeyPurposeId; import org.bouncycastle.asn1.x509.KeyUsage; import org.bouncycastle.asn1.x509.X509Extensions; import org.bouncycastle.x509.X509V3CertificateGenerator; public class MainClass { public static X509Certificate generateV3Certificate(KeyPair pair) throws InvalidKeyException, NoSuchProviderException, SignatureException { Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); X509V3CertificateGenerator certGen = new X509V3CertificateGenerator(); certGen.setSerialNumber(BigInteger.valueOf(System.currentTimeMillis())); certGen.setIssuerDN(new X500Principal("CN=Test Certificate")); certGen.setNotBefore(new Date(System.currentTimeMillis() - 10000)); certGen.setNotAfter(new Date(System.currentTimeMillis() + 10000)); certGen.setSubjectDN(new X500Principal("CN=Test Certificate")); certGen.setPublicKey(pair.getPublic()); certGen.setSignatureAlgorithm("SHA256WithRSAEncryption"); certGen.addExtension(X509Extensions.BasicConstraints, true, new BasicConstraints(false)); certGen.addExtension(X509Extensions.KeyUsage, true, new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyEncipherment)); certGen.addExtension(X509Extensions.ExtendedKeyUsage, true, new ExtendedKeyUsage( KeyPurposeId.id_kp_serverAuth)); certGen.addExtension(X509Extensions.SubjectAlternativeName, false, new GeneralNames( new GeneralName(GeneralName.rfc822Name, "test@test.test"))); return certGen.generateX509Certificate(pair.getPrivate(), "BC"); } public static void main(String[] args) throws Exception { Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); KeyPair pair = generateRSAKeyPair(); X509Certificate cert = generateV3Certificate(pair); cert.checkValidity(new Date()); cert.verify(cert.getPublicKey()); } public static KeyPair generateRSAKeyPair() throws Exception { KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA", "BC"); kpGen.initialize(1024, new SecureRandom()); return kpGen.generateKeyPair(); } } */ /* * Use X.509 certificate import java.io.BufferedWriter; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.OutputStreamWriter; import java.security.cert.Certificate; import java.security.cert.CertificateFactory; public class MainClass { public static void main(String args[]) throws Exception { CertificateFactory cf = CertificateFactory.getInstance("X.509"); FileInputStream in = new FileInputStream(args[0]); Certificate c = cf.generateCertificate(in); in.close(); String s = c.toString(); FileOutputStream fout = new FileOutputStream("tmp.txt"); BufferedWriter out = new BufferedWriter(new OutputStreamWriter(fout)); out.write(s, 0, s.length()); out.close(); } } */ } ParseCertificate.java000077500000000000000000000016631406641055200345720ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/certificates/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.certificates; public class ParseCertificate { } ValidateCertificate.java000077500000000000000000000050321406641055200352430ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/certificates/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.certificates; import java.security.PublicKey; import java.security.cert.X509Certificate; public class ValidateCertificate { private static String CERT_DIR = "/data/certs/"; public static void main(final String[] args) throws Exception { final ValidateCertificate verifyCertificate = new ValidateCertificate(); verifyCertificate.runSample(); } public void runSample() throws Exception { /* * Load and verify each certificate. 1. Load certificates into * X509Certificate object 2. Verify each certificate using its * corresponding public key of the issuer certificate. */ // X509Certificate cert = CertUtil.loadX509Certificate(CERT_DIR // + "janet.crt"); // X509Certificate issuerCA = CertUtil.loadX509Certificate(CERT_DIR // + "CAphoenix.crt"); // X509Certificate rootCA = CertUtil.loadX509Certificate(CERT_DIR // + "CAseattle.crt"); // verifySignature(rootCA, rootCA); // verifySignature(rootCA, issuerCA); // verifySignature(issuerCA, cert); } /* * Verify certificate's signature. * * @param issuer The X509 issuer certificate. * * @param cert The X509 certificate to be verified. * * @throws Exception On failure. */ private void verifySignature(final X509Certificate issuer, final X509Certificate cert) throws Exception { final PublicKey verifyingKey = issuer.getPublicKey(); /* * Verify the signature on the certificate using the public key. This * method returns void on successful validation and in case of of a * failure in verification, it throws a Signature Exception. */ cert.verify(verifyingKey); } } ValidateCertificationPath.java000077500000000000000000000064131406641055200364250ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/certificates/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.certificates; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.security.InvalidAlgorithmParameterException; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.security.cert.CertPath; import java.security.cert.CertPathValidator; import java.security.cert.CertPathValidatorException; import java.security.cert.CertPathValidatorResult; import java.security.cert.CertificateException; import java.security.cert.PKIXCertPathValidatorResult; import java.security.cert.PKIXParameters; import java.security.cert.TrustAnchor; public class ValidateCertificationPath { public static byte[] validate(final CertPath certPath) throws Exception { try { //TODO: pay attention that this class maybe uses deprecated java.security.* final KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType()); final String password = "changeit"; // Load the JDK's cacerts keystore file final Path filename = Paths.get(System.getProperty("java.home"), "lib", "security", "cacerts"); try (final InputStream is = Files.newInputStream(filename)) { keystore.load(is, password.toCharArray()); } // Create the parameters for the validator final PKIXParameters params = new PKIXParameters(keystore); // Disable CRL checking since we are not supplying any CRLs params.setRevocationEnabled(false); // Create the validator and validate the path // To create a path, see Creating a Certification Path final CertPathValidator certPathValidator = CertPathValidator.getInstance(CertPathValidator.getDefaultType()); final CertPathValidatorResult result = certPathValidator.validate(certPath, params); // Get the CA used to validate this path final PKIXCertPathValidatorResult pkixResult = (PKIXCertPathValidatorResult) result; final TrustAnchor ta = pkixResult.getTrustAnchor(); java.security.cert.X509Certificate cert = ta.getTrustedCert(); } catch (CertificateException | KeyStoreException | NoSuchAlgorithmException | CertPathValidatorException | InvalidAlgorithmParameterException e) { } return null; } } ValidateCertificationRequest.java000077500000000000000000000016771406641055200371700ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/certificates/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.certificates; public class ValidateCertificationRequest { } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digest/000077500000000000000000000000001406641055200273725ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digest/Hash.java000077500000000000000000000072301406641055200311250ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Base64; import java.util.Optional; import javax.annotation.Nullable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ro.kuberam.libs.java.crypto.CryptoError; import ro.kuberam.libs.java.crypto.CryptoException; import ro.kuberam.libs.java.crypto.utils.Buffer; import ro.kuberam.libs.java.crypto.utils.HexString; /** * Implements the crypto:hash() function. * * @author Claudius * Teodorescu */ public class Hash { private static final Logger LOG = LoggerFactory.getLogger(Hash.class); public static String hashString(final String data, final String algorithm) throws CryptoException { return hashString(data, algorithm, null); } public static String hashString(final String data, final String algorithm, final @Nullable String format) throws CryptoException { // TODO: validate the format final String actualFormat = Optional.ofNullable(format).filter(str -> !str.isEmpty()).orElse("base64"); final MessageDigest messageDigester = getMessageDigester(algorithm); messageDigester.update(data.getBytes(StandardCharsets.UTF_8)); final byte[] resultBytes = messageDigester.digest(); if (actualFormat.equals("base64")) { return Base64.getEncoder().encodeToString(resultBytes); } else { return HexString.fromBytes(resultBytes); } } public static String hashBinary(final InputStream data, final String algorithm) throws CryptoException, IOException { return hashBinary(data, algorithm, null); } public static String hashBinary(final InputStream data, final String algorithm, @Nullable final String format) throws CryptoException, IOException { // TODO: validate the format final String actualFormat = Optional.ofNullable(format).filter(str -> !str.isEmpty()).orElse("base64"); final byte[] resultBytes; final MessageDigest messageDigester = getMessageDigester(algorithm); final byte[] buf = new byte[Buffer.TRANSFER_SIZE]; int read = -1; while ((read = data.read(buf)) > -1) { messageDigester.update(buf, 0, read); } resultBytes = messageDigester.digest(); final String result; if (actualFormat.equals("base64")) { result = Base64.getEncoder().encodeToString(resultBytes); } else { result = HexString.fromBytes(resultBytes); } LOG.debug("hash value is = {}", result); return result; } private static MessageDigest getMessageDigester(final String algorithm) throws CryptoException { try { return MessageDigest.getInstance(algorithm); } catch (NoSuchAlgorithmException e) { throw new CryptoException(CryptoError.NoSuchAlgorithmException, e); } } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digest/Hmac.java000077500000000000000000000103671406641055200311170ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import java.io.IOException; import java.io.InputStream; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.util.Base64; import java.util.Map; import java.util.Optional; import javax.annotation.Nullable; import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; import jakarta.xml.bind.DatatypeConverter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ro.kuberam.libs.java.crypto.CryptoException; import ro.kuberam.libs.java.crypto.ExpathCryptoModule; import ro.kuberam.libs.java.crypto.utils.Buffer; public class Hmac { private static final Logger LOG = LoggerFactory.getLogger(Hmac.class); public static String hmac(final byte[] data, final byte[] secretKey, final String algorithm, @Nullable final String format) throws CryptoException { // TODO: validate the format final String actualFormat = Optional.ofNullable(format).filter(str -> !str.isEmpty()).orElse("base64"); LOG.debug("secretKey = {}", secretKey); final byte[] resultBytes = hmac(data, secretKey, algorithm); final String result; if (actualFormat.equals("base64")) { result = Base64.getEncoder().encodeToString(resultBytes); } else { result = DatatypeConverter.printHexBinary(resultBytes).toLowerCase(); } LOG.debug("result = {}", result); return result; } public static String hmac(final InputStream data, final byte[] secretKey, final String algorithm, @Nullable final String format) throws CryptoException, IOException { // TODO: validate the format String actualFormat = Optional.ofNullable(format).filter(str -> !str.isEmpty()).orElse("base64"); LOG.debug("secretKey = {}", secretKey); byte[] resultBytes = hmac(data, secretKey, algorithm); String result; if (actualFormat.equals("base64")) { result = Base64.getEncoder().encodeToString(resultBytes); } else { result = DatatypeConverter.printHexBinary(resultBytes).toLowerCase(); } LOG.debug("result = {}", result); return result; } public static byte[] hmac(final byte[] data, final byte[] secretKey, String algorithm) throws CryptoException { final Map javaStandardAlgorithmNames = ExpathCryptoModule.javaStandardAlgorithmNames; if (javaStandardAlgorithmNames.containsKey(algorithm)) { algorithm = javaStandardAlgorithmNames.get(algorithm); } final SecretKeySpec signingKey = new SecretKeySpec(secretKey, algorithm); try { final Mac mac = Mac.getInstance(algorithm); mac.init(signingKey); return mac.doFinal(data); } catch (NoSuchAlgorithmException | InvalidKeyException e) { throw CryptoException.fromCause(e); } } public static byte[] hmac(final InputStream data, final byte[] secretKey, String algorithm) throws CryptoException, IOException { final Map javaStandardAlgorithmNames = ExpathCryptoModule.javaStandardAlgorithmNames; if (javaStandardAlgorithmNames.containsKey(algorithm)) { algorithm = javaStandardAlgorithmNames.get(algorithm); } final SecretKeySpec signingKey = new SecretKeySpec(secretKey, algorithm); try { Mac mac = Mac.getInstance(algorithm); mac.init(signingKey); byte[] buf = new byte[Buffer.TRANSFER_SIZE]; int read = -1; while ((read = data.read(buf)) > -1) { mac.update(buf, 0, read); } return mac.doFinal(); } catch (NoSuchAlgorithmException | InvalidKeyException e) { throw CryptoException.fromCause(e); } } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/000077500000000000000000000000001406641055200314125ustar00rootroot00000000000000GenerateSignature.java000077500000000000000000000216351406641055200356240ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.io.InputStream; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.KeyStore; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Signature; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; import javax.xml.crypto.XMLStructure; import javax.xml.crypto.dom.DOMStructure; import javax.xml.crypto.dsig.Reference; import javax.xml.crypto.dsig.SignedInfo; import javax.xml.crypto.dsig.Transform; import javax.xml.crypto.dsig.XMLObject; import javax.xml.crypto.dsig.XMLSignature; import javax.xml.crypto.dsig.XMLSignatureFactory; import javax.xml.crypto.dsig.dom.DOMSignContext; import javax.xml.crypto.dsig.keyinfo.KeyInfo; import javax.xml.crypto.dsig.keyinfo.KeyInfoFactory; import javax.xml.crypto.dsig.keyinfo.KeyValue; import javax.xml.crypto.dsig.keyinfo.X509Data; import javax.xml.crypto.dsig.keyinfo.X509IssuerSerial; import javax.xml.crypto.dsig.spec.C14NMethodParameterSpec; import javax.xml.crypto.dsig.spec.TransformParameterSpec; import javax.xml.crypto.dsig.spec.XPathFilterParameterSpec; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.xpath.XPath; import javax.xml.xpath.XPathConstants; import javax.xml.xpath.XPathExpression; import javax.xml.xpath.XPathFactory; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.w3c.dom.bootstrap.DOMImplementationRegistry; import org.w3c.dom.ls.DOMImplementationLS; import org.w3c.dom.ls.LSSerializer; public class GenerateSignature { public static byte[] generateSignature(byte[] data, PrivateKey key, String algorithm, String provider) throws Exception { Signature signer = Signature.getInstance(algorithm); signer.initSign(key); signer.update(data); return signer.sign(); } public static String GenerateDigitalSignature(org.w3c.dom.Document inputDoc, String canonicalizationAlgorithmURI, String digestAlgorithmURI, String signatureAlgorithmURI, String keyPairAlgorithm, String signatureNamespacePrefix, String signatureType, String xpathExprString, String[] certificateDetails, InputStream keyStoreInputStream) throws Exception { // Create a DOM XMLSignatureFactory String providerName = System.getProperty("jsr105Provider", "org.jcp.xml.dsig.internal.dom.XMLDSigRI"); XMLSignatureFactory sigFactory = XMLSignatureFactory.getInstance("DOM"); // Create a Reference to the signed element Node sigParent; List transforms; if (xpathExprString == null) { sigParent = inputDoc.getDocumentElement(); transforms = Collections .singletonList(sigFactory.newTransform(Transform.ENVELOPED, (TransformParameterSpec) null)); } else { XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); // Find the node to be signed by PATH XPathExpression expr = xpath.compile(xpathExprString); NodeList nodes = (NodeList) expr.evaluate(inputDoc, XPathConstants.NODESET); if (nodes.getLength() < 1) { throw new Exception("Can't find node by this XPath expression: " + xpathExprString); } // Node nodeToSign = nodes.item(0); // sigParent = nodeToSign.getParentNode(); sigParent = nodes.item(0); /* * if ( signatureType.equals( "enveloped" ) ) { sigParent = ( nodes.item(0) * ).getParentNode(); } */ transforms = Arrays.asList( sigFactory.newTransform(Transform.XPATH, new XPathFilterParameterSpec(xpathExprString)), sigFactory.newTransform(Transform.ENVELOPED, (TransformParameterSpec) null)); } Reference ref = sigFactory.newReference("", sigFactory.newDigestMethod(digestAlgorithmURI, null), transforms, null, null); // http://www.massapi.com/source/xml-security-1_4_4/src/org/jcp/xml/dsig/internal/dom/DOMXPathFilter2Transform.java.html // Create the SignedInfo SignedInfo si = sigFactory.newSignedInfo( sigFactory.newCanonicalizationMethod(canonicalizationAlgorithmURI, (C14NMethodParameterSpec) null), sigFactory.newSignatureMethod(signatureAlgorithmURI, null), Collections.singletonList(ref)); // generate key pair KeyInfo ki; PrivateKey privateKey; if (certificateDetails[0].length() != 0) { KeyStore keyStore; try { keyStore = KeyStore.getInstance(certificateDetails[0]); } catch (Exception ex) { throw new Exception("The keystore type '" + certificateDetails[0] + "' is not supported!."); } keyStore.load(keyStoreInputStream, certificateDetails[1].toCharArray()); String alias = certificateDetails[2]; if (!keyStore.containsAlias(alias)) { throw new Exception("Cannot find key for alias '" + alias + "' in given keystore!."); } privateKey = (PrivateKey) keyStore.getKey(alias, certificateDetails[3].toCharArray()); X509Certificate cert = (X509Certificate) keyStore.getCertificate(alias); PublicKey publicKey = cert.getPublicKey(); KeyInfoFactory kif = sigFactory.getKeyInfoFactory(); List kiContent = new ArrayList<>(); KeyValue keyValue = kif.newKeyValue(publicKey); kiContent.add(keyValue); List x509Content = new ArrayList<>(); X509IssuerSerial issuer = kif.newX509IssuerSerial(cert.getIssuerX500Principal().getName(), cert.getSerialNumber()); x509Content.add(cert.getSubjectX500Principal().getName()); x509Content.add(issuer); x509Content.add(cert); X509Data x509Data = kif.newX509Data(x509Content); kiContent.add(x509Data); ki = kif.newKeyInfo(kiContent); } else { KeyPairGenerator kpg = KeyPairGenerator.getInstance(keyPairAlgorithm); kpg.initialize(512); KeyPair kp = kpg.generateKeyPair(); KeyInfoFactory kif = sigFactory.getKeyInfoFactory(); KeyValue kv = kif.newKeyValue(kp.getPublic()); ki = kif.newKeyInfo(Collections.singletonList(kv)); privateKey = kp.getPrivate(); } /* * SOLVED * SOLVED SOLVED * > */ // Create a DOMSignContext and specify the location of the resulting // XMLSignature's parent element DOMSignContext dsc; XMLSignature signature; Document signatureDoc = null; if (signatureType.equals("enveloped")) { dsc = new DOMSignContext(privateKey, sigParent); signature = sigFactory.newXMLSignature(si, ki); } else if (signatureType.equals("detached")) { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); sigParent = dbf.newDocumentBuilder().newDocument(); dsc = new DOMSignContext(privateKey, sigParent); signature = sigFactory.newXMLSignature(si, ki); } else if (signatureType.equals("enveloping")) { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); signatureDoc = dbf.newDocumentBuilder().newDocument(); XMLStructure content = new DOMStructure(sigParent); XMLObject xmlobj = sigFactory.newXMLObject(Collections.singletonList(content), "object", null, null); dsc = new DOMSignContext(privateKey, signatureDoc); signature = sigFactory.newXMLSignature(si, ki, Collections.singletonList(xmlobj), null, null); } else { // TODO(AR) error, as below will cause NPE... dsc = null; signature = null; } dsc.setDefaultNamespacePrefix(signatureNamespacePrefix); // Marshal, generate and sign signature.sign(dsc); DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance(); DOMImplementationLS impl = (DOMImplementationLS) registry.getDOMImplementation("LS"); LSSerializer serializer = impl.createLSSerializer(); if (signatureType.equals("enveloping")) { return serializer.writeToString(signatureDoc); } else { return serializer.writeToString(sigParent); } } } GenerateSignatureOnBinary.java000077500000000000000000000040171406641055200372610ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Signature; import ro.kuberam.libs.java.crypto.keyManagement.GenerateKeyPair; public class GenerateSignatureOnBinary { public static byte[] generateSignatureOnBinary(final byte[] data, final PrivateKey privateKey, final String algorithm) throws Exception { final Signature dsa = Signature.getInstance(algorithm); dsa.initSign(privateKey); dsa.update(data); return dsa.sign(); } public static boolean verifySig(final byte[] data, final PublicKey key, final byte[] sig) throws Exception { final Signature signer = Signature.getInstance("SHA1withDSA"); signer.initVerify(key); signer.update(data); return signer.verify(sig); } public static void main(final String args[]) throws Exception { final KeyPair keyPair = GenerateKeyPair.generate("SHA1PRNG", 1008, "base64"); final byte[] data = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 }; final byte[] signature = generateSignatureOnBinary(data, keyPair.getPrivate(), "SHA1withDSA"); System.out.println("Signature:\n" + new String(signature)); } } GenerateXmlSignature.java000077500000000000000000000277531406641055200363140ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.io.IOException; import java.io.InputStream; import java.security.*; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import java.util.*; import javax.xml.crypto.MarshalException; import javax.xml.crypto.XMLStructure; import javax.xml.crypto.dom.DOMStructure; import javax.xml.crypto.dsig.*; import javax.xml.crypto.dsig.dom.DOMSignContext; import javax.xml.crypto.dsig.keyinfo.KeyInfo; import javax.xml.crypto.dsig.keyinfo.KeyInfoFactory; import javax.xml.crypto.dsig.keyinfo.KeyValue; import javax.xml.crypto.dsig.keyinfo.X509Data; import javax.xml.crypto.dsig.keyinfo.X509IssuerSerial; import javax.xml.crypto.dsig.spec.C14NMethodParameterSpec; import javax.xml.crypto.dsig.spec.TransformParameterSpec; import javax.xml.crypto.dsig.spec.XPathFilterParameterSpec; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import javax.xml.xpath.*; import org.w3c.dom.Document; import org.w3c.dom.Node; import org.w3c.dom.NodeList; import org.w3c.dom.bootstrap.DOMImplementationRegistry; import org.w3c.dom.ls.DOMImplementationLS; import org.w3c.dom.ls.LSSerializer; import ro.kuberam.libs.java.crypto.CryptoError; import ro.kuberam.libs.java.crypto.CryptoException; /** * Implements the module definition. * * @author Claudius * Teodorescu */ public class GenerateXmlSignature { public static String generate(Document inputDoc, String canonicalizationAlgorithm, String digestAlgorithm, String signatureAlgorithm, String signatureNamespacePrefix, String signatureType, String xpathExprString, String[] certificateDetails, InputStream keyStoreInputStream) throws CryptoException, IOException, XMLSignatureException { String mechanismType = "DOM"; return generate(inputDoc, mechanismType, canonicalizationAlgorithm, digestAlgorithm, signatureAlgorithm, signatureNamespacePrefix, signatureType, xpathExprString, certificateDetails, keyStoreInputStream); } public static String generate(Document inputDoc, String mechanismType, String canonicalizationAlgorithm, String digestAlgorithm, String signatureAlgorithm, String signatureNamespacePrefix, String signatureType, String xpathExprString, String[] certificateDetails, InputStream keyStoreInputStream) throws CryptoException, IOException, XMLSignatureException { String canonicalizationAlgorithmURI = getCanonicalizationAlgorithmUri(canonicalizationAlgorithm); String digestAlgorithmURI = getDigestAlgorithmURI(digestAlgorithm); String signatureAlgorithmURI = getSignatureAlgorithmURI(signatureAlgorithm); String keyPairAlgorithm = signatureAlgorithm.substring(0, 3); // Create a DOM XMLSignatureFactory XMLSignatureFactory sigFactory = XMLSignatureFactory.getInstance(mechanismType); // Create a Reference to the signed element Node sigParent = null; List transforms; try { if (xpathExprString == null) { sigParent = inputDoc.getDocumentElement(); transforms = Collections .singletonList(sigFactory.newTransform(Transform.ENVELOPED, (TransformParameterSpec) null)); } else { XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); // Find the node to be signed by PATH XPathExpression expr = xpath.compile(xpathExprString); NodeList nodes = (NodeList) expr.evaluate(inputDoc, XPathConstants.NODESET); if (nodes.getLength() < 1) { // TODO this error message has to replaced throw new CryptoException(CryptoError.NoSuchAlgorithmException); } // Node nodeToSign = nodes.item(0); // sigParent = nodeToSign.getParentNode(); sigParent = nodes.item(0); /* * if ( signatureType.equals( "enveloped" ) ) { sigParent = ( nodes.item(0) * ).getParentNode(); } */ transforms = Arrays.asList( sigFactory.newTransform(Transform.XPATH, new XPathFilterParameterSpec(xpathExprString)), sigFactory.newTransform(Transform.ENVELOPED, (TransformParameterSpec) null)); } Reference ref = sigFactory.newReference("", sigFactory.newDigestMethod(digestAlgorithmURI, null), transforms, null, null); // Create the SignedInfo SignedInfo si = sigFactory.newSignedInfo( sigFactory.newCanonicalizationMethod(canonicalizationAlgorithmURI, (C14NMethodParameterSpec) null), sigFactory.newSignatureMethod(signatureAlgorithmURI, null), Collections.singletonList(ref)); // generate key pair KeyInfo ki; PrivateKey privateKey; if (certificateDetails[0].length() != 0) { KeyStore keyStore; try { keyStore = KeyStore.getInstance(certificateDetails[0]); } catch (KeyStoreException e) { throw CryptoException.fromCause(e); } keyStore.load(keyStoreInputStream, certificateDetails[1].toCharArray()); String alias = certificateDetails[2]; if (!keyStore.containsAlias(alias)) { throw new CryptoException(CryptoError.ALIAS_KEY); } privateKey = (PrivateKey) keyStore.getKey(alias, certificateDetails[3].toCharArray()); X509Certificate cert = (X509Certificate) keyStore.getCertificate(alias); PublicKey publicKey = cert.getPublicKey(); KeyInfoFactory kif = sigFactory.getKeyInfoFactory(); List kiContent = new ArrayList<>(); KeyValue keyValue = kif.newKeyValue(publicKey); kiContent.add(keyValue); List x509Content = new ArrayList<>(); X509IssuerSerial issuer = kif.newX509IssuerSerial(cert.getIssuerX500Principal().getName(), cert.getSerialNumber()); x509Content.add(cert.getSubjectX500Principal().getName()); x509Content.add(issuer); x509Content.add(cert); X509Data x509Data = kif.newX509Data(x509Content); kiContent.add(x509Data); ki = kif.newKeyInfo(kiContent); } else { KeyPairGenerator kpg = KeyPairGenerator.getInstance(keyPairAlgorithm); kpg.initialize(512); KeyPair kp = kpg.generateKeyPair(); KeyInfoFactory kif = sigFactory.getKeyInfoFactory(); KeyValue kv = kif.newKeyValue(kp.getPublic()); ki = kif.newKeyInfo(Collections.singletonList(kv)); privateKey = kp.getPrivate(); } /* * SOLVED * SOLVED SOLVED * > */ // Create a DOMSignContext and specify the location of the resulting // XMLSignature's parent element DOMSignContext dsc = null; XMLSignature signature = null; Document signatureDoc = null; if (signatureType.equals("enveloped")) { dsc = new DOMSignContext(privateKey, sigParent); signature = sigFactory.newXMLSignature(si, ki); } else if (signatureType.equals("detached")) { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); sigParent = dbf.newDocumentBuilder().newDocument(); dsc = new DOMSignContext(privateKey, sigParent); signature = sigFactory.newXMLSignature(si, ki); } else if (signatureType.equals("enveloping")) { DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); signatureDoc = dbf.newDocumentBuilder().newDocument(); XMLStructure content = new DOMStructure(sigParent); XMLObject xmlobj = sigFactory.newXMLObject(Collections.singletonList(content), "object", null, null); dsc = new DOMSignContext(privateKey, signatureDoc); signature = sigFactory.newXMLSignature(si, ki, Collections.singletonList(xmlobj), null, null); } dsc.setDefaultNamespacePrefix(signatureNamespacePrefix); // Marshal, generate and sign signature.sign(dsc); DOMImplementationRegistry registry; try { registry = DOMImplementationRegistry.newInstance(); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { throw new IOException(e); } DOMImplementationLS impl = (DOMImplementationLS) registry.getDOMImplementation("LS"); LSSerializer serializer = impl.createLSSerializer(); if (signatureType.equals("enveloping")) { return serializer.writeToString(signatureDoc); } else { return serializer.writeToString(sigParent); } } catch (NoSuchAlgorithmException | InvalidAlgorithmParameterException e) { throw new CryptoException(CryptoError.NoSuchAlgorithmException, e); } catch (CertificateException e) { // TODO error code needs improving throw new CryptoException(CryptoError.InvalidKeySpecException, e); } catch (KeyStoreException e) { throw new CryptoException(CryptoError.UNREADABLE_KEYSTORE, e); } catch (UnrecoverableKeyException | KeyException e) { throw new CryptoException(CryptoError.InvalidKeySpecException, e); } catch (ParserConfigurationException | XPathExpressionException | MarshalException e) { throw new IOException(e); } } // public static void main(String[] args) throws // ParserConfigurationException, // SAXException, IOException, Exception { // String docString = // "23"; // DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); // dbf.setNamespaceAware(true); // Document inputDoc = dbf.newDocumentBuilder().parse( // new InputSource(new StringReader(docString))); // // String[] certificateDetails = new String[5]; // certificateDetails[0] = "JKS"; // certificateDetails[1] = "ab987c"; // certificateDetails[2] = "eXist"; // certificateDetails[3] = "kpi135"; // // String domString = generateXmlSignature(inputDoc, // CanonicalizationMethod.EXCLUSIVE, DigestMethod.SHA1, // SignatureMethod.DSA_SHA1, "DSA", "ds", "enveloped", "//b", // certificateDetails, getClass().getResourceAsStream( // "../tests/resources/mykeystoreEXist.ks")); // System.out.print(domString + "\n"); // } private static String getCanonicalizationAlgorithmUri(String canonicalizationAlgorithm) throws CryptoException { switch (canonicalizationAlgorithm) { case "exclusive": return CanonicalizationMethod.EXCLUSIVE; case "exclusive-with-comments": return CanonicalizationMethod.EXCLUSIVE_WITH_COMMENTS; case "inclusive": return CanonicalizationMethod.INCLUSIVE; default: throw new CryptoException(CryptoError.NoSuchAlgorithmException); } } private static String getDigestAlgorithmURI(String digestAlgorithm) throws CryptoException { switch (digestAlgorithm) { case "SHA256": return DigestMethod.SHA256; case "SHA512": return DigestMethod.SHA512; case "SHA1": case "": return DigestMethod.SHA1; default: throw new CryptoException(CryptoError.NoSuchAlgorithmException); } } private static String getSignatureAlgorithmURI(String signatureAlgorithm) throws CryptoException { switch (signatureAlgorithm) { case "DSA_SHA1": return SignatureMethod.DSA_SHA1; case "RSA_SHA1": case "": return SignatureMethod.RSA_SHA1; default: throw new CryptoException(CryptoError.NoSuchAlgorithmException); } } }SignatureForString.java000077500000000000000000000025501406641055200360020ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.nio.charset.StandardCharsets; import java.security.PrivateKey; import java.security.Signature; import java.util.Base64; public class SignatureForString { public static String generate(String data, PrivateKey privateKey, String algorithm) throws Exception { Signature dsa = Signature.getInstance(algorithm); dsa.initSign(privateKey); dsa.update(data.getBytes(StandardCharsets.UTF_8)); return Base64.getEncoder().encodeToString(dsa.sign()); } } ValidateSignatureOnBinary.java000077500000000000000000000040511406641055200372560ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.security.KeyPair; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Signature; import ro.kuberam.libs.java.crypto.keyManagement.GenerateKeyPair; public class ValidateSignatureOnBinary { public static byte[] generateSignatureOnBinary(final byte[] data, final PrivateKey privateKey, final String algorithm) throws Exception { final Signature dsa = Signature.getInstance(algorithm); dsa.initSign(privateKey); dsa.update(data); return dsa.sign(); } public static boolean validateSignatureOnBinary(byte[] data, PublicKey publicKey, byte[] signature, String algorithm) throws Exception { Signature signer = Signature.getInstance(algorithm); signer.initVerify(publicKey); signer.update(data); return signer.verify(signature); } public static void main(final String args[]) throws Exception { final KeyPair keyPair = GenerateKeyPair.generate("SHA1PRNG", 1008, "base64"); final byte[] data = { 65, 66, 67, 68, 69, 70, 71, 72, 73, 74 }; final boolean validate = validateSignatureOnBinary(data, keyPair.getPublic(), null, "SHA1withDSA"); System.out.println("Validate:\n" + validate); } } ValidateXmlSignature.java000077500000000000000000000130611406641055200362760ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.io.IOException; import java.security.Key; import java.security.KeyException; import java.security.PublicKey; import java.util.Iterator; import java.util.List; import javax.xml.crypto.*; import javax.xml.crypto.dsig.*; import javax.xml.crypto.dsig.dom.DOMValidateContext; import javax.xml.crypto.dsig.keyinfo.KeyInfo; import javax.xml.crypto.dsig.keyinfo.KeyValue; import javax.xml.xpath.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.w3c.dom.Document; import org.w3c.dom.Node; import ro.kuberam.libs.java.crypto.CryptoException; /** * Cryptographic extension functions. * * @author Claudius * Teodorescu */ public class ValidateXmlSignature { private static final Logger LOG = LoggerFactory.getLogger(ValidateXmlSignature.class); public static Boolean validate(Document inputDoc) throws CryptoException, IOException, XMLSignatureException { // Find Signature element LOG.debug("Claudius test: {}", inputDoc.getElementsByTagNameNS(XMLSignature.XMLNS, "Signature").getLength()); // NodeList nl = inputDoc.getElementsByTagName("Signature"); // NodeList nl = inputDoc.getElementsByTagNameNS(XMLSignature.XMLNS, // "Signature"); try { XPathFactory factory = XPathFactory.newInstance(); XPath xpath = factory.newXPath(); // Find the node to be signed by PATH XPathExpression expr = xpath .compile("//*[local-name() = 'Signature' and namespace-uri() = '" + XMLSignature.XMLNS + "']"); Node nl = (Node) expr.evaluate(inputDoc, XPathConstants.NODE); // if (nl.getLength() == 0) { // throw new XPathException(ErrorMessages.err_CX15); // } // Create a DOM XMLSignatureFactory that will be used to unmarshal the // document containing the XMLSignature XMLSignatureFactory fac = XMLSignatureFactory.getInstance("DOM"); LOG.debug("Claudius test: {}", nl.getNodeName()); // Create a DOMValidateContext and specify a KeyValue KeySelector // and document context DOMValidateContext valContext = new DOMValidateContext(new KeyValueKeySelector(), nl); // unmarshal the XMLSignature XMLSignature signature = fac.unmarshalXMLSignature(valContext); // Validate the XMLSignature (generated above) boolean coreValidity = signature.validate(valContext); // Check core validation status if (coreValidity == false) { System.err.println("Signature failed core validation"); boolean sv = signature.getSignatureValue().validate(valContext); System.out.println("signature validation status: " + sv); // check the validation status of each Reference Iterator iterator = signature.getSignedInfo().getReferences().iterator(); for (int j = 0; iterator.hasNext(); j++) { boolean refValid = ((Reference) iterator.next()).validate(valContext); System.out.println("ref[" + j + "] validity status: " + refValid); } } return coreValidity; } catch (XPathExpressionException | MarshalException e) { throw new IOException(e); } } /** * KeySelector which retrieves the public key out of the KeyValue element and * returns it. NOTE: If the key algorithm doesn't match signature algorithm, * then the public key will be ignored. */ private static class KeyValueKeySelector extends KeySelector { public KeySelectorResult select(KeyInfo keyInfo, KeySelector.Purpose purpose, AlgorithmMethod method, XMLCryptoContext context) throws KeySelectorException { if (keyInfo == null) { throw new KeySelectorException("Null KeyInfo object!"); } SignatureMethod sm = (SignatureMethod) method; List list = keyInfo.getContent(); for (int i = 0; i < list.size(); i++) { XMLStructure xmlStructure = (XMLStructure) list.get(i); if (xmlStructure instanceof KeyValue) { PublicKey pk = null; try { pk = ((KeyValue) xmlStructure).getPublicKey(); } catch (KeyException ke) { throw new KeySelectorException(ke); } // make sure algorithm is compatible with method if (algEquals(sm.getAlgorithm(), pk.getAlgorithm())) { return new SimpleKeySelectorResult(pk); } } } throw new KeySelectorException("No KeyValue element found!"); } static boolean algEquals(String algURI, String algName) { if (algName.equalsIgnoreCase("DSA") && algURI.equalsIgnoreCase(SignatureMethod.DSA_SHA1)) { return true; } else if (algName.equalsIgnoreCase("RSA") && algURI.equalsIgnoreCase(SignatureMethod.RSA_SHA1)) { return true; } else { return false; } } } private static class SimpleKeySelectorResult implements KeySelectorResult { private PublicKey pk; SimpleKeySelectorResult(PublicKey pk) { this.pk = pk; } public Key getKey() { return pk; } } }crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/encrypt/000077500000000000000000000000001406641055200275775ustar00rootroot00000000000000AsymmetricEncryption.java000077500000000000000000000144731406641055200345670ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/encrypt/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.encrypt; import static java.nio.charset.StandardCharsets.UTF_8; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.security.InvalidKeyException; import java.security.Key; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.security.PublicKey; import java.util.Base64; import java.util.StringTokenizer; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import ro.kuberam.libs.java.crypto.CryptoException; import ro.kuberam.libs.java.crypto.keyManagement.Load; import ro.kuberam.libs.java.crypto.utils.Buffer; /** * @author Claudius * Teodorescu */ public class AsymmetricEncryption { public static String encryptString(String data, Key key, String transformationName) throws CryptoException, IOException { String provider = "SUN"; return encryptString(data, key, transformationName, provider); } public static String encryptString(String data, Key key, String transformationName, String provider) throws CryptoException, IOException { byte[] dataBytes = data.getBytes(UTF_8); byte[] resultBytes = null; Cipher cipher; try { cipher = Cipher.getInstance(transformationName); cipher.init(Cipher.ENCRYPT_MODE, key); resultBytes = cipher.doFinal(dataBytes); } catch (IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) { throw CryptoException.fromCause(e); } catch (Exception e) { e.printStackTrace(); } return Base64.getEncoder().encodeToString(resultBytes); } public static String decryptString(String encryptedData, PrivateKey privateKey, String transformationName) throws CryptoException, IOException { String provider = "SUN"; return decryptString(encryptedData, privateKey, transformationName, provider); } public static String decryptString(String encryptedData, PrivateKey privateKey, String transformationName, String provider) throws CryptoException, IOException { byte[] dataBytes = Base64.getDecoder().decode(encryptedData); byte[] resultBytes = null; Cipher cipher; try { cipher = Cipher.getInstance(transformationName); cipher.init(Cipher.DECRYPT_MODE, privateKey); resultBytes = cipher.doFinal(dataBytes); } catch (IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) { throw CryptoException.fromCause(e); } catch (Exception e) { e.printStackTrace(); } return new String(resultBytes, UTF_8); } public static String encryptBinary(InputStream data, String base64PublicKey, String transformationName, String provider) throws CryptoException, IOException { String algorithm = transformationName.split("/")[0]; byte[] resultBytes = null; Cipher cipher; try { cipher = Cipher.getInstance(transformationName); PublicKey publicKey = Load.publicKey(base64PublicKey, algorithm, provider); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] buf = new byte[Buffer.TRANSFER_SIZE]; int read = -1; while ((read = data.read(buf)) > -1) { cipher.update(buf, 0, read); } resultBytes = cipher.doFinal(); } catch (IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) { throw CryptoException.fromCause(e); } catch (Exception e) { e.printStackTrace(); } return getString(resultBytes); } public static String decryptBinary(InputStream data, String base64PrivateKey, String transformationName, String provider) throws CryptoException, IOException { String algorithm = transformationName.split("/")[0]; byte[] resultBytes = null; Cipher cipher; try { cipher = Cipher.getInstance(transformationName); PrivateKey privateKey = Load.privateKey(base64PrivateKey, algorithm, provider); cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] buf = new byte[Buffer.TRANSFER_SIZE]; int read = -1; while ((read = data.read(buf)) > -1) { cipher.update(buf, 0, read); } resultBytes = cipher.doFinal(); } catch (IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) { throw CryptoException.fromCause(e); } catch (Exception e) { e.printStackTrace(); } return getString(resultBytes); } public static String getString(byte[] bytes) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < bytes.length; i++) { byte b = bytes[i]; sb.append((int) (0x00FF & b)); if (i + 1 < bytes.length) { sb.append("-"); } } return sb.toString(); } public static byte[] getBytes(String str) throws IOException { StringTokenizer st = new StringTokenizer(str, "-", false); try (ByteArrayOutputStream bos = new ByteArrayOutputStream()) { while (st.hasMoreTokens()) { int i = Integer.parseInt(st.nextToken()); bos.write((byte) i); } return bos.toByteArray(); } } } // add providers to loadPublicKey() and loadPrivateKey() // add key length to GenerateKeyPair $key-strength // remove GenerateKeyPair.generate() by replacing it? // add AsymmetricEncryption for binaries // change the output of symmetric encryption to base64Binary string (and tests, too) // add / improve error message for AsymmetricEncryption when the text to be encrypted is larger that the key SymmetricEncryption.java000077500000000000000000000136331406641055200344230ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/encrypt/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.encrypt; import static java.nio.charset.StandardCharsets.UTF_8; import java.io.IOException; import java.security.InvalidAlgorithmParameterException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.util.Optional; 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; import ro.kuberam.libs.java.crypto.CryptoError; import ro.kuberam.libs.java.crypto.CryptoException; /** * @author Claudius * Teodorescu */ public class SymmetricEncryption { public static byte[] encrypt(byte[] input, String plainKey, String transformationName, String iv, String provider) throws CryptoException, IOException { return operation(input, plainKey, transformationName, iv, provider, Cipher.ENCRYPT_MODE); } public static byte[] decrypt(byte[] encryptedInput, final String plainKey, final String transformationName, final String iv, final String provider) throws CryptoException, IOException { return operation(encryptedInput, plainKey, transformationName, iv, provider, Cipher.DECRYPT_MODE); } public static byte[] operation(byte[] input, String secretKey, String transformationName, String iv, String provider, int operationType) throws CryptoException, IOException { String algorithm = (transformationName.contains("/")) ? transformationName.substring(0, transformationName.indexOf("/")) : transformationName; String actualProvider = Optional.ofNullable(provider).filter(str -> !str.isEmpty()).orElse("SunJCE"); Cipher cipher; byte[] result; try { cipher = Cipher.getInstance(transformationName, actualProvider); } catch (NoSuchProviderException | NoSuchAlgorithmException | NoSuchPaddingException e) { throw CryptoException.fromCause(e); } SecretKeySpec skeySpec = generateSecretKey(secretKey, algorithm); if (transformationName.contains("/")) { final IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes(UTF_8), 0, 16); try { cipher.init(operationType, skeySpec, ivSpec); } catch (InvalidAlgorithmParameterException | InvalidKeyException e) { throw CryptoException.fromCause(e); } } else { try { cipher.init(operationType, skeySpec); } catch (InvalidKeyException e) { throw new CryptoException(CryptoError.InvalidKeySpecException, e); } } try { result = cipher.doFinal(input); } catch (IllegalBlockSizeException | BadPaddingException e) { throw CryptoException.fromCause(e); } return result; } private static SecretKeySpec generateSecretKey(String secretKey, String algorithm) { return new SecretKeySpec(secretKey.getBytes(UTF_8), algorithm); } } // import java.security.NoSuchAlgorithmException; // import java.security.SecureRandom; // import java.security.spec.InvalidKeySpecException; // import java.security.spec.KeySpec; // import java.util.Arrays; // // import javax.crypto.SecretKeyFactory; // import javax.crypto.spec.PBEKeySpec; // // public class PasswordEncryptionService { // // public boolean authenticate(String attemptedPassword, byte[] // encryptedPassword, byte[] salt) // throws NoSuchAlgorithmException, InvalidKeySpecException { // // Encrypt the clear-text password using the same salt that was used to // // encrypt the original password // byte[] encryptedAttemptedPassword = getEncryptedPassword(attemptedPassword, // salt); // // // Authentication succeeds if encrypted password that the user entered // // is equal to the stored hash // return Arrays.equals(encryptedPassword, encryptedAttemptedPassword); // } // // public byte[] getEncryptedPassword(String password, byte[] salt) // throws NoSuchAlgorithmException, InvalidKeySpecException { // // PBKDF2 with SHA-1 as the hashing algorithm. Note that the NIST // // specifically names SHA-1 as an acceptable hashing algorithm for PBKDF2 // String algorithm = "PBKDF2WithHmacSHA1"; // // SHA-1 generates 160 bit hashes, so that's what makes sense here // int derivedKeyLength = 160; // // Pick an iteration count that works for you. The NIST recommends at // // least 1,000 iterations: // // http://csrc.nist.gov/publications/nistpubs/800-132/nist-sp800-132.pdf // // iOS 4.x reportedly uses 10,000: // // // http://blog.crackpassword.com/2010/09/smartphone-forensics-cracking-blackberry-backup-passwords/ // int iterations = 20000; // // KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, iterations, // derivedKeyLength); // // SecretKeyFactory f = SecretKeyFactory.getInstance(algorithm); // // return f.generateSecret(spec).getEncoded(); // } // // public byte[] generateSalt() throws NoSuchAlgorithmException { // // VERY important to use SecureRandom instead of just Random // SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); // // // Generate a 8 byte (64 bit) salt as recommended by RSA PKCS5 // byte[] salt = new byte[8]; // random.nextBytes(salt); // // return salt; // } // } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/keyManagement/000077500000000000000000000000001406641055200307005ustar00rootroot00000000000000GenerateKeyPair.java000077500000000000000000000130651406641055200345130ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/keyManagement/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.keyManagement; import java.security.GeneralSecurityException; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; import java.util.Base64; import ro.kuberam.libs.java.crypto.randomSequencesGeneration.RandomNumber; public class GenerateKeyPair { private static Base64.Encoder encoder = Base64.getEncoder(); public static GeneratedKeys run(String algorithm) throws Exception { KeyPairGenerator keyGenerator = getKeyPairGenerator(algorithm); keyGenerator.initialize(2048); KeyPair keys = keyGenerator.generateKeyPair(); final String privateKey = outputPrivatekey(keys.getPrivate().getEncoded(), algorithm); final String publicKey = outputPublickey(keys.getPublic().getEncoded(), algorithm); return new GeneratedKeys(privateKey, publicKey); } public static GeneratedKeys run(String algorithm, String provider) throws Exception { KeyPairGenerator keyGenerator = getKeyPairGenerator(algorithm, provider); keyGenerator.initialize(2048); KeyPair keys = keyGenerator.generateKeyPair(); final String privateKey = outputPrivatekey(keys.getPrivate().getEncoded(), algorithm); final String publicKey = outputPublickey(keys.getPublic().getEncoded(), algorithm); return new GeneratedKeys(privateKey, publicKey); } public static KeyPair generate(String algorithm, long seed, String provider) throws Exception { KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance(algorithm); keyGenerator.initialize(1024, RandomNumber.generate(seed, "SHA1PRNG", provider)); return keyGenerator.generateKeyPair(); } private static String outputPrivatekey(byte[] privateKey, String algorithm) { return "-----BEGIN " + algorithm + " PRIVATE KEY-----\n" + encoder.encodeToString(privateKey) + "\n-----END " + algorithm + " PRIVATE KEY-----\n"; } private static String outputPublickey(byte[] publicKey, String algorithm) { return "-----BEGIN " + algorithm + " PUBLIC KEY-----\n" + encoder.encodeToString(publicKey) + "\n-----END " + algorithm + " PUBLIC KEY-----\n"; } private static KeyPairGenerator getKeyPairGenerator(String algorithm) throws NoSuchAlgorithmException { return KeyPairGenerator.getInstance(algorithm); } private static KeyPairGenerator getKeyPairGenerator(String algorithm, String provider) throws NoSuchAlgorithmException, NoSuchProviderException { return KeyPairGenerator.getInstance(algorithm, provider); } public static String savePrivateKey(PrivateKey priv) throws GeneralSecurityException { KeyFactory fact = KeyFactory.getInstance("EllipticCurve"); PKCS8EncodedKeySpec spec = fact.getKeySpec(priv, PKCS8EncodedKeySpec.class); return Base64.getEncoder().encodeToString(spec.getEncoded()); } public static String savePublicKey(PublicKey publ) throws GeneralSecurityException { KeyFactory fact = KeyFactory.getInstance("EllipticCurve"); X509EncodedKeySpec spec = fact.getKeySpec(publ, X509EncodedKeySpec.class); return Base64.getEncoder().encodeToString(spec.getEncoded()); } public static class GeneratedKeys { private final String privateKey; private final String publicKey; public GeneratedKeys(final String privateKey, final String publicKey) { this.privateKey = privateKey; this.publicKey = publicKey; } public String getPrivateKey() { return privateKey; } public String getPublicKey() { return publicKey; } } } // public static PrivateKey loadPrivateKey(String key64) throws // GeneralSecurityException { // byte[] clear = base64Decode(key64); // PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(clear); // KeyFactory fact = KeyFactory.getInstance("DSA"); // PrivateKey priv = fact.generatePrivate(keySpec); // Arrays.fill(clear, (byte) 0); // return priv; // } // // // public static PublicKey loadPublicKey(String stored) throws // GeneralSecurityException { // byte[] data = base64Decode(stored); // X509EncodedKeySpec spec = new X509EncodedKeySpec(data); // KeyFactory fact = KeyFactory.getInstance("DSA"); // return fact.generatePublic(spec); // } // // public static void main(String[] args) throws Exception { // KeyPairGenerator gen = KeyPairGenerator.getInstance("DSA"); // KeyPair pair = gen.generateKeyPair(); // // String pubKey = savePublicKey(pair.getPublic()); // PublicKey pubSaved = loadPublicKey(pubKey); // System.out.println(pair.getPublic()+"\n"+pubSaved); // // String privKey = savePrivateKey(pair.getPrivate()); // PrivateKey privSaved = loadPrivateKey(privKey); // System.out.println(pair.getPrivate()+"\n"+privSaved); // } GenerateSecretKey.java000077500000000000000000000033621406641055200350440ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/keyManagement/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.keyManagement; import java.security.NoSuchAlgorithmException; import java.util.Base64; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; public class GenerateSecretKey { public static SecretKey run(String algorithm) { KeyGenerator keyGen = null; try { /* * Get KeyGenerator object that generates secret keys for the specified * algorithm. */ keyGen = KeyGenerator.getInstance(algorithm); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } /* Initializes this key generator for key size to 256. */ keyGen.init(256); /* Generates a secret key */ SecretKey secretKey = keyGen.generateKey(); return secretKey; } public static void main(String args[]) { SecretKey secretKey = run("AES"); String encodedKey = Base64.getEncoder().encodeToString(secretKey.getEncoded()); System.out.println(encodedKey); } }crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/keyManagement/Load.java000077500000000000000000000051071406641055200324300ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.keyManagement; import java.security.KeyFactory; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.spec.InvalidKeySpecException; import java.security.spec.PKCS8EncodedKeySpec; import java.security.spec.X509EncodedKeySpec; import java.util.Base64; import java.util.Optional; import java.util.regex.Pattern; public class Load { private static Pattern pattern = Pattern.compile("(?m)(?s)^---*BEGIN.*---*$(.*)^---*END.*---*$.*"); public static PublicKey publicKey(String base64PublicKey, String algorithm, String provider) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException { provider = Optional.ofNullable(provider).filter(str -> !str.isEmpty()).orElse("SunRsaSign"); String cleanedKey = cleanKey(base64PublicKey); X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.getMimeDecoder().decode(cleanedKey)); KeyFactory kf = KeyFactory.getInstance(algorithm, provider); return kf.generatePublic(spec); } public static PrivateKey privateKey(String base64PrivateKey, String algorithm, String provider) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException { provider = Optional.ofNullable(provider).filter(str -> !str.isEmpty()).orElse("SunRsaSign"); String cleanedKey = cleanKey(base64PrivateKey); PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.getMimeDecoder().decode(cleanedKey)); KeyFactory kf = KeyFactory.getInstance(algorithm, provider); return kf.generatePrivate(keySpec); } private static String cleanKey(String base64Key) { return pattern.matcher(base64Key).replaceFirst("$1"); } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/providers/000077500000000000000000000000001406641055200301305ustar00rootroot00000000000000ListAvailableCryptographicServices.java000077500000000000000000000201201406641055200376710ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/providers/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ /* * To change this template, choose Tools | Templates * and open the template in the editor. */ package ro.kuberam.libs.java.crypto.providers; /** * @author claudius */ // ----------------------------------------------------------------------------- // ListAvailableCryptographicServices.java // ----------------------------------------------------------------------------- /* * ============================================================================= * Copyright (c) 1998-2009 Jeffrey M. Hunter. All rights reserved. * * All source code and material located at the Internet address of * http://www.idevelopment.info is the copyright of Jeffrey M. Hunter and * is protected under copyright laws of the United States. This source code may * not be hosted on any other site without my express, prior, written * permission. Application to host any of the material elsewhere can be made by * contacting me at jhunter@idevelopment.info. * * I have made every effort and taken great care in making sure that the source * code and other content included on my web site is technically accurate, but I * disclaim any and all responsibility for any loss, damage or destruction of * data or any other property which may arise from relying on it. I will in no * case be liable for any monetary damages arising from such loss, damage or * destruction. * * As with any code, ensure to test this code in a development environment * before attempting to run it in production. * ============================================================================= */ import java.security.Provider; import java.security.Security; import java.util.Arrays; import java.util.Set; import java.util.HashSet; import java.util.Iterator; /** * ----------------------------------------------------------------------------- * The providers of cryptographic services such as key generation algorithms, * register their services with the Security class. A service is * represented by a name of the form: * * service-type.service-implementation * * An example of a service entry is: * SecureRandom.SHA1PRNG * ----------------------------------------------------------------------------- * @version 1.0 * @author Jeffrey M. Hunter (jhunter@idevelopment.info) * @author http://www.idevelopment.info * ----------------------------------------------------------------------------- */ public class ListAvailableCryptographicServices { /** * This method returns all available services types. * @return String[] object that is a list of all available * service types. */ private static String[] getServiceTypes() { final Set result = new HashSet<>(); // All providers final Provider[] providers = Security.getProviders(); for (int i = 0; i < providers.length; i++) { // Get services provided by each provider final Set keys = providers[i].keySet(); for (final Iterator it = keys.iterator(); it.hasNext(); ) { String key = (String) it.next(); key = key.split(" ")[0]; if (key.startsWith("Alg.Alias")) { // Strip the alias key = key.substring(10); } final int ix = key.indexOf('.'); result.add(key.substring(0, ix)); } } return result.toArray(new String[result.size()]); } /** * This method returns the available implementations for a given * service type. * @param serviceType A String object that represents a particular service * type * @return String[] object that is a list of all available * service type implementations. */ private static String[] getCryptoImpls(final String serviceType) { final Set result = new HashSet<>(); // All providers final Provider[] providers = Security.getProviders(); for (int i = 0; i < providers.length; i++) { // Get services provided by each provider final Set keys = providers[i].keySet(); for (final Iterator it = keys.iterator(); it.hasNext(); ) { String key = (String) it.next(); key = key.split(" ")[0]; if (key.startsWith(serviceType + ".")) { result.add(key.substring(serviceType.length() + 1)); } else if (key.startsWith("Alg.Alias." + serviceType + ".")) { // This is an alias result.add(key.substring(serviceType.length() + 11)); } } } return result.toArray(new String[result.size()]); } /** * Print all Service Types (sorted) to STDOUT. */ private static void listServiceTypes() { System.out.println(); System.out.println("Service Types"); System.out.println("-------------"); final String[] serviceTypes = getServiceTypes(); Arrays.sort(serviceTypes); for (int i = 0; i < serviceTypes.length; i++) { System.out.println(" - " + serviceTypes[i]); } System.out.println(); } /** * Print all Service Type Implementations (sorted) to STDOUT. */ private static void listCryptoImpls() { System.out.println(); System.out.println("Service Type Implementations"); System.out.println("----------------------------"); final String[] serviceTypes = getServiceTypes(); Arrays.sort(serviceTypes); for (int i = 0; i < serviceTypes.length; i++) { System.out.println(); System.out.println(" - " + serviceTypes[i]); final String[] serviceTypeImpls = getCryptoImpls(serviceTypes[i]); Arrays.sort(serviceTypeImpls); for (int j = 0; j < serviceTypeImpls.length; j++) { System.out.println(" " + serviceTypeImpls[j]); } } System.out.println(); } public static void main(final String[] args) { listServiceTypes(); listCryptoImpls(); } } //http://exampledepot.com/egs/java.security/ListServices.html //http://informit.com/guides/content.aspx?g=java&seqNum=31 /*String providerName = "SUN version 1.6"; Provider providers[]; if(null != args && 0 < args.length) { providers = new Provider[args.length]; for(int i = 0; i < args.length; i++) providers[i] = Security.getProvider(args[i]); } else { providers = Security.getProviders(); } for(int i = 0; i < providers.length; i++) { Provider p = providers[i]; System.out.println("Provider: " + p); System.out.println("==============================="); System.out.println("provider properties:"); ArrayList keys = new ArrayList(p.keySet()); Collections.sort(keys); String key; for(Iterator j = keys.iterator(); j.hasNext(); System.out.println(key + "=" + p.get(key))) key = (String)j.next(); System.out.println("-------------------------------"); }*/ crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/providers/ListProviders.java000077500000000000000000000101601406641055200336050ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; import java.io.IOException; import java.io.StringWriter; import java.security.Provider; import java.security.Security; import java.util.Date; import java.util.Iterator; import java.util.Set; import javax.xml.stream.FactoryConfigurationError; import javax.xml.stream.XMLOutputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamWriter; import javax.xml.transform.stream.StreamResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ro.kuberam.libs.java.crypto.ExpathCryptoModule; public class ListProviders { private static final Logger LOG = LoggerFactory.getLogger(ListProviders.class); private static String moduleNsUri = ExpathCryptoModule.NAMESPACE_URI; private static String modulePrefix = ExpathCryptoModule.PREFIX; public static StreamResult listProviders() throws XMLStreamException, FactoryConfigurationError, IOException { final long startTime = new Date().getTime(); try (final StringWriter writer = new StringWriter()) { final XMLStreamWriter xmlWriter = XMLOutputFactory.newInstance() .createXMLStreamWriter(writer); xmlWriter.setPrefix(modulePrefix, moduleNsUri); xmlWriter.writeStartDocument(); xmlWriter.writeStartElement(modulePrefix + ":providers-list"); xmlWriter.writeNamespace(modulePrefix, moduleNsUri); for (final Provider provider : Security.getProviders()) { xmlWriter.writeStartElement(modulePrefix + ":provider"); xmlWriter.writeAttribute("name", provider.getName()); xmlWriter.writeAttribute("version", Double.toString(provider.getVersion())); final Set keys = provider.keySet(); System.out.println(provider.elements().nextElement().toString()); for (Iterator it = keys.iterator(); it.hasNext(); ) { String key = (String) it.next(); key = key.split(" ")[0]; if (key.startsWith("Alg.Alias")) { // Strip the alias key = key.substring(10); } final int ix = key.indexOf('.'); //System.out.println(key); } xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); xmlWriter.writeEndDocument(); xmlWriter.close(); final StreamResult resultAsStreamResult = new StreamResult(writer); LOG.debug("The list with cryptographic providers was generated in {} ms.", (new Date().getTime() - startTime)); return resultAsStreamResult; } } } //import java.security.Provider; //import java.security.Security; //import java.util.Enumeration; // //public class MainClass { // public static void main(String[] args) throws Exception { // try { // Provider p[] = Security.getProviders(); // for (int i = 0; i < p.length; i++) { // System.out.println(p[i]); // for (Enumeration e = p[i].keys(); e.hasMoreElements();) // System.out.println("\t" + e.nextElement()); // } // } catch (Exception e) { // System.out.println(e); // } // } //}crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/providers/ListServices.java000077500000000000000000000056171406641055200334260ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; /** * @author claudius */ import java.io.IOException; import java.io.StringWriter; import java.security.Provider; import java.security.Security; import java.util.Date; import javax.xml.stream.FactoryConfigurationError; import javax.xml.stream.XMLOutputFactory; import javax.xml.stream.XMLStreamException; import javax.xml.stream.XMLStreamWriter; import javax.xml.transform.stream.StreamResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import ro.kuberam.libs.java.crypto.ExpathCryptoModule; public class ListServices { private static final Logger LOG = LoggerFactory.getLogger(ListServices.class); private static String moduleNsUri = ExpathCryptoModule.NAMESPACE_URI; private static String modulePrefix = ExpathCryptoModule.PREFIX; public static StreamResult listServices(final String providerName) throws XMLStreamException, FactoryConfigurationError, IOException { final long startTime = new Date().getTime(); try (final StringWriter writer = new StringWriter()) { final XMLStreamWriter xmlWriter = XMLOutputFactory.newInstance().createXMLStreamWriter(writer); xmlWriter.setPrefix(modulePrefix, moduleNsUri); xmlWriter.writeStartDocument(); xmlWriter.writeStartElement(modulePrefix + ":providers-list"); xmlWriter.writeNamespace(modulePrefix, moduleNsUri); for (final Provider provider : Security.getProviders()) { xmlWriter.writeStartElement(modulePrefix + ":provider"); xmlWriter.writeCharacters(provider.getName()); xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); xmlWriter.writeEndDocument(); xmlWriter.close(); final StreamResult resultAsStreamResult = new StreamResult(writer); LOG.debug("The list with cryptographic services for provider {} was generated in {} ms.", providerName, (new Date().getTime() - startTime)); return resultAsStreamResult; } } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/providers/SetProvider.java000077500000000000000000000016531406641055200332510ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; public class SetProvider { } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/providers/defaultProvider/000077500000000000000000000000001406641055200332675ustar00rootroot00000000000000ExpathCrypto.java000077500000000000000000000105501406641055200365110ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/providers/defaultProvider/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers.defaultProvider; import java.security.AccessController; import java.security.Provider; public class ExpathCrypto extends Provider { /** * */ private static final long serialVersionUID = -3274955405729286576L; private static String info = "SunJCE Provider " + "(implements DES, Triple DES, Blowfish, PBE, Diffie-Hellman, HMAC-MD5, " + "HMAC-SHA1)"; public ExpathCrypto() { /* We are the "base64" provider */ super("ExpathCrypto", 1.4, info); AccessController.doPrivileged(new java.security.PrivilegedAction() { public Object run() { /* * Cipher engines */ put("Cipher.DES", "com.sun.crypto.provider.DESCipher"); put("Cipher.DESede", "com.sun.crypto.provider.DESedeCipher"); put("Alg.Alias.Cipher.TripleDES", "DESede"); put("Cipher.PBEWithMD5AndDES", "com.sun.crypto.provider.PBEWithMD5AndDESCipher"); put("Cipher.PBEWithMD5AndTripleDES", "com.sun.crypto.provider.PBEWithMD5AndTripleDESCipher"); put("Cipher.Blowfish", "com.sun.crypto.provider.BlowfishCipher"); /* * Key(pair) Generator engines */ put("KeyGenerator.DES", "com.sun.crypto.provider.DESKeyGenerator"); put("KeyGenerator.DESede", "com.sun.crypto.provider.DESedeKeyGenerator"); put("Alg.Alias.KeyGenerator.TripleDES", "DESede"); put("KeyGenerator.Blowfish", "com.sun.crypto.provider.BlowfishKeyGenerator"); put("KeyGenerator.HmacMD5", "com.sun.crypto.provider.HmacMD5KeyGenerator"); put("KeyGenerator.HmacSHA1", "com.sun.crypto.provider.HmacSHA1KeyGenerator"); put("KeyPairGenerator.DiffieHellman", "com.sun.crypto.provider.DHKeyPairGenerator"); put("Alg.Alias.KeyPairGenerator.DH", "DiffieHellman"); /* * Algorithm parameter generation engines */ put("AlgorithmParameterGenerator.DiffieHellman", "com.sun.crypto.provider.DHParameterGenerator"); put("Alg.Alias.AlgorithmParameterGenerator.DH", "DiffieHellman"); /* * Key Agreement engines */ put("KeyAgreement.DiffieHellman", "com.sun.crypto.provider.DHKeyAgreement"); put("Alg.Alias.KeyAgreement.DH", "DiffieHellman"); /* * Algorithm Parameter engines */ put("AlgorithmParameters.DiffieHellman", "com.sun.crypto.provider.DHParameters"); put("Alg.Alias.AlgorithmParameters.DH", "DiffieHellman"); put("AlgorithmParameters.DES", "com.sun.crypto.provider.DESParameters"); put("AlgorithmParameters.DESede", "com.sun.crypto.provider.DESedeParameters"); put("Alg.Alias.AlgorithmParameters.TripleDES", "DESede"); put("AlgorithmParameters.PBE", "com.sun.crypto.provider.PBEParameters"); put("Alg.Alias.AlgorithmParameters.PBEWithMD5AndDES", "PBE"); put("AlgorithmParameters.Blowfish", "com.sun.crypto.provider.BlowfishParameters"); /* * Key factories */ put("KeyFactory.DiffieHellman", "com.sun.crypto.provider.DHKeyFactory"); put("Alg.Alias.KeyFactory.DH", "DiffieHellman"); /* * Secret-key factories */ put("SecretKeyFactory.DES", "com.sun.crypto.provider.DESKeyFactory"); put("SecretKeyFactory.DESede", "com.sun.crypto.provider.DESedeKeyFactory"); put("Alg.Alias.SecretKeyFactory.TripleDES", "DESede"); put("SecretKeyFactory.PBEWithMD5AndDES", "com.sun.crypto.provider.PBEKeyFactory"); /* * MAC */ put("Mac.HmacMD5", "com.sun.crypto.provider.HmacMD5"); put("Mac.HmacSHA1", "com.sun.crypto.provider.HmacSHA1"); /* * KeyStore */ put("KeyStore.JCEKS", "com.sun.crypto.provider.JceKeyStore"); return null; } }); } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/randomSequencesGeneration/000077500000000000000000000000001406641055200332635ustar00rootroot00000000000000RandomNumber.java000077500000000000000000000033211406641055200364420ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/randomSequencesGeneration/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.randomSequencesGeneration; import java.security.SecureRandom; public class RandomNumber { public static SecureRandom generate(final long seed, final String algorithm, final String provider) throws Exception { final SecureRandom randomNumber = SecureRandom.getInstance(algorithm, provider); randomNumber.setSeed(seed); return randomNumber; } public static SecureRandom generate(final String algorithm, final String provider) throws Exception { final SecureRandom randomNumber = SecureRandom.getInstance(algorithm, provider); return randomNumber; } public static void main(final String args[]) throws Exception { final SecureRandom randomNumber = generate(1008, "SHA1PRNG", "SUN"); System.out.println("Random number:\n" + randomNumber.nextLong()); } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/000077500000000000000000000000001406641055200307265ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/AddEntry.java000077500000000000000000000154571406641055200333220ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; import java.security.Key; import java.security.cert.Certificate; public class AddEntry { public boolean add() { boolean added = true; return added; } private boolean addKey(final String alias, final Key key, final char[] password, final Certificate[] certificateChain) { boolean added = true; return added; } private boolean addCertificate(final String alias, final Certificate certificate) { boolean added = true; return added; } } //import java.security.*; //import java.security.spec.*; //import java.security.cert.*; //import java.io.*; //import java.util.*; // //public class KeyStoreImport { // // public static void main(String args[]) { // try { // // Meaningful variable names for the arguments // String keyStoreFileName = args[0]; // String certificateChainFileName = args[1]; // String privateKeyFileName = args[2]; // String entryAlias = args[3]; // // // Get the password for the keystore. // System.out.println("Keystore password: "); // // String keyStorePassword = (new BufferedReader( // new InputStreamReader(System.in))).readLine(); // // // Load the keystore // KeyStore keyStore = KeyStore.getInstance("jks"); // FileInputStream keyStoreInputStream = new FileInputStream( // keyStoreFileName); // keyStore.load(keyStoreInputStream, keyStorePassword.toCharArray()); // keyStoreInputStream.close(); // // // Load the certificate chain (in X.509 DER encoding). // FileInputStream certificateStream = new FileInputStream( // certificateChainFileName); // CertificateFactory certificateFactory = CertificateFactory // .getInstance("X.509"); // // Required because Java is STUPID. You can't just cast the result // // of toArray to Certificate[]. // java.security.cert.Certificate[] chain = {}; // chain = certificateFactory.generateCertificates(certificateStream) // .toArray(chain); // certificateStream.close(); // // // Load the private key (in PKCS#8 DER encoding). // File keyFile = new File(privateKeyFileName); // byte[] encodedKey = new byte[(int) keyFile.length()]; // FileInputStream keyInputStream = new FileInputStream(keyFile); // keyInputStream.read(encodedKey); // keyInputStream.close(); // KeyFactory rSAKeyFactory = KeyFactory.getInstance("RSA"); // PrivateKey privateKey = rSAKeyFactory // .generatePrivate(new PKCS8EncodedKeySpec(encodedKey)); // // // Add the new entry // System.out.println("Private key entry password: "); // // String privateKeyEntryPassword = (new BufferedReader( // new InputStreamReader(System.in))).readLine(); // keyStore.setEntry(entryAlias, new KeyStore.PrivateKeyEntry( // privateKey, chain), new KeyStore.PasswordProtection( // privateKeyEntryPassword.toCharArray())); // // // Write out the keystore // FileOutputStream keyStoreOutputStream = new FileOutputStream( // keyStoreFileName); // keyStore.store(keyStoreOutputStream, keyStorePassword.toCharArray()); // keyStoreOutputStream.close(); // } // // catch (Exception e) { // e.printStackTrace(); // System.exit(1); // } // } //} //import java.io.*; //import java.security.*; //import javax.crypto.*; //import javax.crypto.spec.*; //import java.util.*; // //public class StoreKey //{ // private static String keyFile, cipherFile; // private static String password; // private static FileOutputStream keyOutFile, cipherOutFile; // // public static void main(String[] args) throws Exception // { // // // Create the password key and initialize the cipher // // for encryption // // String password = "super_secret_password"; // PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray()); // SecretKeyFactory keyFactory = // SecretKeyFactory.getInstance("PBEWithMD5AndDES"); // SecretKey passwordKey = keyFactory.generateSecret(keySpec); // // byte[] salt = new byte[8]; // Random rnd = new Random(); // rnd.nextBytes(salt); // int iterations = 1000; // // PBEParameterSpec parameterSpec = new PBEParameterSpec(salt, iterations); // // Cipher cipher = Cipher.getInstance("PBEWithMD5AndDES"); // cipher.init(Cipher.ENCRYPT_MODE, passwordKey, parameterSpec); // // // // Create a secret key using the DESede algorithm which // // may be used by applications for symmetric encryption. // // KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede"); // keyGenerator.init(168); // SecretKey secretKey = keyGenerator.generateKey(); // // // Write something encrypted to a file ("secretStuff") with // // this secret key // // String clearText = "I sure love working with the JCE."; // byte[] clearTextBytes = clearText.getBytes("UTF8"); // // Cipher cipher2 = Cipher.getInstance("DESede"); // cipher2.init(Cipher.ENCRYPT_MODE, secretKey); // // byte[] cipherBytes = cipher2.doFinal(clearTextBytes); // // // A little "hack" here to see how many bytes were encoded. // // This value will be "hardcoded" in RetrieveKey.java // // System.out.println(cipherBytes.length); // // cipherFile = "secretStuff"; // cipherOutFile = new FileOutputStream(cipherFile); // // cipherOutFile.write(cipherBytes); // // cipherOutFile.close(); // // // Get the bytes of this secret key and encrypted them, // // byte[] secretKeyBytes = secretKey.getEncoded(); // byte[] secretKeyBytesEncrypted = cipher.doFinal(secretKeyBytes); // // // A little "hack" to see how many bytes make up the encrypted // // secret key. // // System.out.println(secretKeyBytesEncrypted.length); // // // Write the salt and the encrypted secret key to the file; // // salt is needed when reconstructing the PBE key for decryption. // // keyFile = "key.bin"; // keyOutFile = new FileOutputStream(keyFile); // // keyOutFile.write(salt); // keyOutFile.write(secretKeyBytesEncrypted); // // keyOutFile.close(); // } //}ConvertSecureStore.java000077500000000000000000000016661406641055200353320ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; public class ConvertSecureStore { } CreateSecureStore.java000077500000000000000000000034351406641055200351110ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.security.cert.CertificateException; public class CreateSecureStore { public static byte[] create(final String password) throws NoSuchAlgorithmException, CertificateException, IOException, KeyStoreException { final KeyStore ks = KeyStore.getInstance("JKS"); final char[] passwordCharArray = password.toCharArray(); ks.load(null, passwordCharArray); try (final ByteArrayOutputStream baos = new ByteArrayOutputStream()) { ks.store(baos, passwordCharArray); return baos.toByteArray(); } } public static void main(final String[] args) throws Exception { System.out.println(new String(create("password"))); } } DeleteEntry.java000077500000000000000000000016571406641055200337520ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; public class DeleteEntry { } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/GetEntry.java000077500000000000000000000016541406641055200333430ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; public class GetEntry { } GetEntryMetadata.java000077500000000000000000000016641406641055200347260ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; public class GetEntryMetadata { } GetSecureStoreMetadata.java000077500000000000000000000016721406641055200360670ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; public class GetSecureStoreMetadata { } ListTrustedCertificateAuthorities.java000077500000000000000000000052301406641055200403670ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.security.InvalidAlgorithmParameterException; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.security.cert.CertificateException; import java.security.cert.PKIXParameters; import java.security.cert.TrustAnchor; import java.security.cert.X509Certificate; import java.util.Iterator; public class ListTrustedCertificateAuthorities { public static void main(final String[] args) { // Load the JDK's cacerts keystore file final Path filename = Paths.get(System.getProperty("java.home"), "lib", "security", "cacerts"); try (final InputStream is = Files.newInputStream(filename)) { final KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType()); final String password = "changeit"; keystore.load(is, password.toCharArray()); // This class retrieves the most-trusted CAs from the keystore final PKIXParameters params = new PKIXParameters(keystore); // Get the set of trust anchors, which contain the most-trusted CA certificates final Iterator it = params.getTrustAnchors().iterator(); while (it.hasNext()) { final TrustAnchor ta = (TrustAnchor) it.next(); // Get certificate final X509Certificate cert = ta.getTrustedCert(); System.out.println(cert.getIssuerDN()); } } catch (CertificateException | KeyStoreException | InvalidAlgorithmParameterException | NoSuchAlgorithmException | IOException e) { //what? } } } LoadSecureStore.java000077500000000000000000000016631406641055200345660ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; public class LoadSecureStore { } ReloadableX509TrustManager.java000077500000000000000000000101751406641055200364760ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/secureStorage/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.secureStorage; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Paths; import java.security.KeyStore; import java.security.NoSuchAlgorithmException; import java.security.cert.Certificate; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import javax.net.ssl.TrustManager; import javax.net.ssl.TrustManagerFactory; import javax.net.ssl.X509TrustManager; class ReloadableX509TrustManager implements X509TrustManager { private final String trustStorePath; private X509TrustManager trustManager; //private List tempCertList = new List(); public ReloadableX509TrustManager(final String tspath) throws Exception { this.trustStorePath = tspath; reloadTrustManager(); } @Override public X509Certificate[] getAcceptedIssuers() { final X509Certificate[] issuers = trustManager.getAcceptedIssuers(); return issuers; } private void reloadTrustManager() throws Exception { // load keystore from specified cert store (or default) final KeyStore ts = KeyStore.getInstance(KeyStore.getDefaultType()); try (final InputStream in = Files.newInputStream(Paths.get(trustStorePath))) { ts.load(in, null); } // add all temporary certs to KeyStore (ts) //TODO: this below has to be commented out to work // for (Certificate cert : tempCertList) { // ts.setCertificateEntry(UUID.randomUUID().toString(), cert); // } // initialize a new TMF with the ts we just loaded final TrustManagerFactory tmf = TrustManagerFactory .getInstance(TrustManagerFactory.getDefaultAlgorithm()); tmf.init(ts); // acquire X509 trust manager from factory final TrustManager tms[] = tmf.getTrustManagers(); for (int i = 0; i < tms.length; i++) { if (tms[i] instanceof X509TrustManager) { trustManager = (X509TrustManager) tms[i]; return; } } throw new NoSuchAlgorithmException( "No X509TrustManager in TrustManagerFactory"); } private void addServerCertAndReload(final Certificate cert, final boolean permanent) { try { if (permanent) { // import the cert into file trust store // Google "java keytool source" or just ... Runtime.getRuntime().exec("keytool -importcert ..."); } else { //TODO: this below has to be commented out to work // tempCertList.add(cert); } reloadTrustManager(); } catch (Exception ex) { /* ... */ //what? } } @Override public void checkClientTrusted(final X509Certificate[] chain, final String authType) throws CertificateException { trustManager.checkClientTrusted(chain, authType); } @Override public void checkServerTrusted(final X509Certificate[] chain, final String authType) throws CertificateException { try { trustManager.checkServerTrusted(chain, authType); } catch (CertificateException cx) { addServerCertAndReload(chain[0], true); trustManager.checkServerTrusted(chain, authType); } } }crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/toDo/000077500000000000000000000000001406641055200270205ustar00rootroot00000000000000GenerateCertificationRequest.java000077500000000000000000000106701406641055200354220ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/toDo/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.toDo; //import java.io.ByteArrayOutputStream; //import java.io.PrintStream; //import java.security.KeyPair; //import java.security.KeyPairGenerator; //import java.security.NoSuchAlgorithmException; //import java.security.PrivateKey; //import java.security.PublicKey; //import java.security.SecureRandom; //import java.security.Signature; // //import sun.security.pkcs.PKCS10; //import sun.security.x509.X500Name; //import sun.security.x509.X500Signer; public class GenerateCertificationRequest { // // private static PublicKey publicKey = null; // private static PrivateKey privateKey = null; // private static KeyPairGenerator keyGen = null; // private static GenerateCertificationRequest gcsr = null; // private static PKCS10 parseCSR; // // private GenerateCertificationRequest() { // try { // keyGen = KeyPairGenerator.getInstance("RSA"); // } catch (NoSuchAlgorithmException e) { // e.printStackTrace(); // } // keyGen.initialize(2048, new SecureRandom()); // KeyPair keypair = keyGen.generateKeyPair(); // publicKey = keypair.getPublic(); // privateKey = keypair.getPrivate(); // } // // public static GenerateCertificationRequest getInstance() { // if (gcsr == null) // gcsr = new GenerateCertificationRequest(); // return gcsr; // } // // /** // * // * @param CN // * Common Name, is X.509 speak for the name that distinguishes // * the Certificate best, and ties it to your Organization // * @param OU // * Organizational unit // * @param O // * Organization NAME // * @param L // * Location // * @param S // * State // * @param C // * Country // * @return // * @throws Exception // */ // private byte[] generatePKCS10(String CN, String OU, String O, // String L, String S, String C) throws Exception { // // generate PKCS10 certificate request // String sigAlg = "MD5WithRSA"; // PKCS10 pkcs10 = new PKCS10(publicKey); // Signature signature = Signature.getInstance(sigAlg); // signature.initSign(privateKey); // // common, orgUnit, org, locality, state, country // X500Name x500Name = new X500Name(CN, OU, O, L, S, C); // pkcs10.encodeAndSign(new X500Signer(signature, x500Name)); // ByteArrayOutputStream bs = new ByteArrayOutputStream(); // PrintStream ps = new PrintStream(bs); // pkcs10.print(ps); // byte[] c = bs.toByteArray(); // try { // if (ps != null) // ps.close(); // if (bs != null) // bs.close(); // } catch (Throwable th) { // } // return c; // } // // public PublicKey getPublicKey() { // return publicKey; // } // // public PrivateKey getPrivateKey() { // return privateKey; // } // // public static void main(String[] args) throws Exception { // GenerateCertificationRequest gcsr = GenerateCertificationRequest.getInstance(); // // //System.out.println("Public Key:\n"+gcsr.getPublicKey().toString()); // // //System.out.println("Private Key:\n"+gcsr.getPrivateKey().toString()); // // byte[] csr = gcsr.generatePKCS10("journaldev.com ", "Java", "JournalDev", "Cupertino", // "California", "USA"); // parseCSR = new PKCS10(csr); // // System.out.println("\n"); // System.out.println(parseCSR.getSubjectName()); // } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/toDo/Rfc2898DeriveBytes.java000077500000000000000000000145421406641055200331070ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.toDo; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmException; import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; import static java.nio.charset.StandardCharsets.UTF_8; /** * RFC 2898 password derivation compatible with .NET Rfc2898DeriveBytes class. * http://www.jmedved.com/2010/05/java-rfc2898derivebytes/ */ public class Rfc2898DeriveBytes { private final Mac _hmacSha1; private final byte[] _salt; private final int _iterationCount; private byte[] _buffer = new byte[20]; private int _bufferStartIndex = 0; private int _bufferEndIndex = 0; private int _block = 1; /** * Creates new instance. * * @param password The password used to derive the key. * @param salt The key salt used to derive the key. * @param iterations The number of iterations for the operation. * @throws NoSuchAlgorithmException HmacSHA1 algorithm cannot be found. * @throws InvalidKeyException Salt must be 8 bytes or more. -or- Password cannot be null. */ public Rfc2898DeriveBytes(final byte[] password, final byte[] salt, final int iterations) throws NoSuchAlgorithmException, InvalidKeyException { if ((salt == null) || (salt.length < 8)) { throw new InvalidKeyException("Salt must be 8 bytes or more."); } if (password == null) { throw new InvalidKeyException("Password cannot be null."); } this._salt = salt; this._iterationCount = iterations; this._hmacSha1 = Mac.getInstance("HmacSHA1"); this._hmacSha1.init(new SecretKeySpec(password, "HmacSHA1")); } /** * Creates new instance. * * @param password The password used to derive the key. * @param salt The key salt used to derive the key. * @param iterations The number of iterations for the operation. * @throws NoSuchAlgorithmException HmacSHA1 algorithm cannot be found. * @throws InvalidKeyException Salt must be 8 bytes or more. -or- Password cannot be null. * @throws UnsupportedEncodingException UTF-8 encoding is not supported. */ public Rfc2898DeriveBytes(final String password, final byte[] salt, final int iterations) throws InvalidKeyException, NoSuchAlgorithmException, UnsupportedEncodingException { this(password.getBytes(UTF_8), salt, iterations); } /** * Creates new instance. * * @param password The password used to derive the key. * @param salt The key salt used to derive the key. * @throws NoSuchAlgorithmException HmacSHA1 algorithm cannot be found. * @throws InvalidKeyException Salt must be 8 bytes or more. -or- Password cannot be null. * @throws UnsupportedEncodingException UTF-8 encoding is not supported. */ public Rfc2898DeriveBytes(final String password, final byte[] salt) throws NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException { this(password, salt, 0x3e8); } /** * Returns a pseudo-random key from a password, salt and iteration count. * * @param count Number of bytes to return. * @return Byte array. */ public byte[] getBytes(final int count) { final byte[] result = new byte[count]; int resultOffset = 0; final int bufferCount = this._bufferEndIndex - this._bufferStartIndex; if (bufferCount > 0) { //if there is some data in buffer if (count < bufferCount) { //if there is enough data in buffer System.arraycopy(this._buffer, this._bufferStartIndex, result, 0, count); this._bufferStartIndex += count; return result; } System.arraycopy(this._buffer, this._bufferStartIndex, result, 0, bufferCount); this._bufferStartIndex = this._bufferEndIndex = 0; resultOffset += bufferCount; } while (resultOffset < count) { final int needCount = count - resultOffset; this._buffer = this.func(); if (needCount > 20) { //we one (or more) additional passes System.arraycopy(this._buffer, 0, result, resultOffset, 20); resultOffset += 20; } else { System.arraycopy(this._buffer, 0, result, resultOffset, needCount); this._bufferStartIndex = needCount; this._bufferEndIndex = 20; return result; } } return result; } private byte[] func() { this._hmacSha1.update(this._salt, 0, this._salt.length); byte[] tempHash = this._hmacSha1.doFinal(getBytesFromInt(this._block)); this._hmacSha1.reset(); byte[] finalHash = tempHash; for (int i = 2; i <= this._iterationCount; i++) { tempHash = this._hmacSha1.doFinal(tempHash); for (int j = 0; j < 20; j++) { finalHash[j] = (byte) (finalHash[j] ^ tempHash[j]); } } if (this._block == 2147483647) { this._block = -2147483648; } else { this._block += 1; } return finalHash; } private static byte[] getBytesFromInt(final int i) { return new byte[]{(byte) (i >>> 24), (byte) (i >>> 16), (byte) (i >>> 8), (byte) i}; } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/toDo/SignFileExample.java000077500000000000000000000212341406641055200327040ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.toDo; import java.io.InputStream; import java.io.OutputStream; import java.nio.file.Files; import java.nio.file.Paths; import java.security.*; import java.security.cert.X509Certificate; import java.util.*; import javax.xml.crypto.dsig.*; import javax.xml.crypto.dsig.dom.DOMSignContext; import javax.xml.crypto.dsig.keyinfo.*; import javax.xml.crypto.dsig.spec.*; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.transform.*; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import javax.xml.xpath.*; import org.w3c.dom.*; /** * Sign XML file. */ public class SignFileExample { private static String KEY_STORE_TYPE = "JKS"; private static String KEY_STORE_NAME = "/home/claudius/mykeystoreEXist.ks"; private static String KEY_STORE_PASS = "ab987c"; private static String PRIVATE_KEY_PASS = "kpi135"; private static String KEY_ALIAS = "eXist"; private static String PATH = "/PatientRecord/Account"; private static String ID = "acct"; private static enum SignatureType { SIGN_BY_ID, SIGN_BY_PATH, SIGN_WHOLE_DOCUMENT } public static void main(final String[] args) throws Exception { /*if (args.length < 2) { usage(); return; }*/ final String inputFile = "doc.xml"; final String outputFile = "doc-signed.xml"; final SignatureType sigType; if (args.length >= 3) { if ("id".equals(args[2])) { sigType = SignatureType.SIGN_BY_ID; } else if ("path".equals(args[2])) { sigType = SignatureType.SIGN_BY_PATH; } else { sigType = SignatureType.SIGN_WHOLE_DOCUMENT; } } else { sigType = SignatureType.SIGN_WHOLE_DOCUMENT; } // Instantiate the document to be signed final DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); dbFactory.setNamespaceAware(true); final Document doc; try (final InputStream is = Files.newInputStream(Paths.get(inputFile))) { doc = dbFactory .newDocumentBuilder() .parse(is); } // prepare signature factory final String providerName = System.getProperty( "jsr105Provider", "org.jcp.xml.dsig.internal.dom.XMLDSigRI" ); final XMLSignatureFactory sigFactory = XMLSignatureFactory.getInstance( "DOM", (Provider) Class.forName(providerName).newInstance() ); Node nodeToSign = null; Node sigParent = null; String referenceURI = null; XPathExpression expr = null; NodeList nodes; List transforms = null; final XPathFactory factory = XPathFactory.newInstance(); final XPath xpath = factory.newXPath(); switch (sigType) { case SIGN_BY_ID: expr = xpath.compile( String.format("//*[@id='%s']", ID) ); nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET); if (nodes.getLength() == 0) { System.out.println("Can't find node with id: " + ID); return; } nodeToSign = nodes.item(0); sigParent = nodeToSign.getParentNode(); referenceURI = "#" + ID; /* * This is not needed since the signature is alongside the signed element, not enclosed in it. transforms = Collections.singletonList( sigFactory.newTransform( Transform.ENVELOPED, (TransformParameterSpec) null ) ); */ break; case SIGN_BY_PATH: // Find the node to be signed by PATH expr = xpath.compile(PATH); nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET); if (nodes.getLength() < 1) { System.out.println("Invalid document, can't find node by PATH: " + PATH); return; } nodeToSign = nodes.item(0); sigParent = nodeToSign.getParentNode(); referenceURI = ""; // Empty string means whole document transforms = new ArrayList() {{ add(sigFactory.newTransform( Transform.XPATH, new XPathFilterParameterSpec(PATH) ) ); add(sigFactory.newTransform( Transform.ENVELOPED, (TransformParameterSpec) null ) ); }}; break; default: sigParent = doc.getDocumentElement(); referenceURI = ""; // Empty string means whole document transforms = Collections.singletonList( sigFactory.newTransform( Transform.ENVELOPED, (TransformParameterSpec) null ) ); break; } // Retrieve signing key final KeyStore keyStore; try (final InputStream is = Files.newInputStream(Paths.get(KEY_STORE_NAME))) { keyStore = KeyStore.getInstance(KEY_STORE_TYPE); keyStore.load(is, KEY_STORE_PASS.toCharArray()); } final PrivateKey privateKey = (PrivateKey) keyStore.getKey(KEY_ALIAS, PRIVATE_KEY_PASS.toCharArray()); final X509Certificate cert = (X509Certificate) keyStore.getCertificate(KEY_ALIAS); PublicKey publicKey = cert.getPublicKey(); // Create a KeyValue containing the RSA PublicKey final KeyInfoFactory keyInfoFactory = sigFactory.getKeyInfoFactory(); final KeyValue keyValue = keyInfoFactory.newKeyValue(publicKey); // Create a KeyInfo and add the KeyValue to it final KeyInfo keyInfo = keyInfoFactory.newKeyInfo(Collections.singletonList(keyValue)); // Create a Reference to the enveloped document final Reference ref = sigFactory.newReference( referenceURI, sigFactory.newDigestMethod(DigestMethod.SHA1, null), transforms, null, null ); // Create the SignedInfo final SignedInfo signedInfo = sigFactory.newSignedInfo( sigFactory.newCanonicalizationMethod( CanonicalizationMethod.INCLUSIVE_WITH_COMMENTS, (C14NMethodParameterSpec) null ), sigFactory.newSignatureMethod( SignatureMethod.DSA_SHA1, null ), Collections.singletonList(ref) ); // Create a DOMSignContext and specify the RSA PrivateKey and // location of the resulting XMLSignature's parent element final DOMSignContext dsc = new DOMSignContext( privateKey, sigParent ); // Create the XMLSignature (but don't sign it yet) final XMLSignature signature = sigFactory.newXMLSignature(signedInfo, keyInfo); // Marshal, generate (and sign) the enveloped signature signature.sign(dsc); // output the resulting document try (final OutputStream os = Files.newOutputStream(Paths.get(args[1]))) { final Transformer trans = TransformerFactory.newInstance().newTransformer(); trans.transform(new DOMSource(doc), new StreamResult(os)); } } private static void usage() { System.out.println("Usage: java SignFile [id|path|whole]"); } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/toDo/X509KeySelector.java000077500000000000000000000364661406641055200325240ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.toDo; import java.io.IOException; import java.security.Key; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.PublicKey; import java.security.cert.Certificate; import java.security.cert.CertificateFactory; import java.security.cert.CertSelector; import java.security.cert.X509Certificate; import java.security.cert.X509CertSelector; import java.util.Enumeration; import java.util.Iterator; import javax.security.auth.x500.X500Principal; import javax.xml.crypto.*; import javax.xml.crypto.dsig.*; import javax.xml.crypto.dsig.keyinfo.*; /** * A KeySelector that returns {@link PublicKey}s of trusted * {@link X509Certificate}s stored in a {@link KeyStore}. * * This KeySelector uses the specified KeyStore * to find a trusted X509Certificate that matches information * specified in the {@link KeyInfo} passed to the {@link #select} method. * The public key from the first match is returned. If no match, * null is returned. See the select method for more * information. * * NOTE!: This X509KeySelector requires J2SE 1.4 because it uses the * java.security.cert.X509CertSelector & javax.security.auth.x500.X500Principal * classes to parse X.500 DNs and match on certificate attributes. * * @author Sean Mullan */ public class X509KeySelector extends KeySelector { private KeyStore ks; /** * Creates an X509KeySelector. * * @param keyStore the keystore * @throws KeyStoreException if the keystore has not been initialized * @throws NullPointerException if keyStore is * null */ public X509KeySelector(final KeyStore keyStore) throws KeyStoreException { if (keyStore == null) { throw new NullPointerException("keyStore is null"); } this.ks = keyStore; // test to see if KeyStore has been initialized this.ks.size(); } /** * Finds a key from the keystore satisfying the specified constraints. * * This method compares data contained in {@link KeyInfo} entries * with information stored in the KeyStore. The implementation * iterates over the KeyInfo types and returns the first {@link PublicKey} * of an X509Certificate in the keystore that is compatible with the * specified AlgorithmMethod according to the following rules for each * keyinfo type: * * X509Data X509Certificate: if it contains a KeyUsage * extension that asserts the digitalSignature bit and * matches an X509Certificate in the KeyStore. * X509Data X509IssuerSerial: if the serial number and issuer DN match an * X509Certificate in the KeyStore. * X509Data X509SubjectName: if the subject DN matches an * X509Certificate in the KeyStore. * X509Data X509SKI: if the subject key identifier matches an * X509Certificate in the KeyStore. * KeyName: if the keyname matches an alias in the KeyStore. * RetrievalMethod: supports rawX509Certificate and X509Data types. If * rawX509Certificate type, it must match an X509Certificate * in the KeyStore. * * @param keyInfo a KeyInfo (may be null) * @param purpose the key's purpose * @param method the algorithm method that this key is to be used for. * Only keys that are compatible with the algorithm and meet the * constraints of the specified algorithm should be returned. * @param context XMLCryptoContext that may contain additional * useful information for finding an appropriate key * @return a key selector result * @throws KeySelectorException if an exceptional condition occurs while * attempting to find a key. Note that an inability to find a key is not * considered an exception (null should be * returned in that case). However, an error condition (ex: network * communications failure) that prevented the KeySelector * from finding a potential key should be considered an exception. * @throws ClassCastException if the data type of method * is not supported by this key selector */ @Override public KeySelectorResult select(final KeyInfo keyInfo, final KeySelector.Purpose purpose, final AlgorithmMethod method, final XMLCryptoContext context) throws KeySelectorException { final SignatureMethod sm = (SignatureMethod) method; try { // return null if keyinfo is null or keystore is empty if (keyInfo == null || ks.size() == 0) { return new SimpleKeySelectorResult(null); } // Iterate through KeyInfo types final Iterator i = keyInfo.getContent().iterator(); while (i.hasNext()) { final XMLStructure kiType = (XMLStructure) i.next(); // check X509Data if (kiType instanceof X509Data) { final X509Data xd = (X509Data) kiType; final KeySelectorResult ksr = x509DataSelect(xd, sm); if (ksr != null) { return ksr; } // check KeyName } else if (kiType instanceof KeyName) { final KeyName kn = (KeyName) kiType; final Certificate cert = ks.getCertificate(kn.getName()); if (cert != null && algEquals(sm.getAlgorithm(), cert.getPublicKey().getAlgorithm())) { return new SimpleKeySelectorResult(cert.getPublicKey()); } // check RetrievalMethod } else if (kiType instanceof RetrievalMethod) { final RetrievalMethod rm = (RetrievalMethod) kiType; try { KeySelectorResult ksr = null; if (rm.getType().equals (X509Data.RAW_X509_CERTIFICATE_TYPE)) { final OctetStreamData data = (OctetStreamData) rm.dereference(context); final CertificateFactory cf = CertificateFactory.getInstance("X.509"); final X509Certificate cert = (X509Certificate) cf.generateCertificate(data.getOctetStream()); ksr = certSelect(cert, sm); } else if (rm.getType().equals(X509Data.TYPE)) { final NodeSetData nd = (NodeSetData) rm.dereference(context); // convert nd to X509Data // ksr = x509DataSelect(xd, sm); } else { // skip; keyinfo type is not supported continue; } if (ksr != null) { return ksr; } } catch (Exception e) { throw new KeySelectorException(e); } } } } catch (KeyStoreException kse) { // throw exception if keystore is uninitialized throw new KeySelectorException(kse); } // return null since no match could be found return new SimpleKeySelectorResult(null); } /** * Searches the specified keystore for a certificate that matches the * criteria specified in the CertSelector. * * @return a KeySelectorResult containing the cert's public key if there * is a match; otherwise null */ private KeySelectorResult keyStoreSelect(final CertSelector cs) throws KeyStoreException { final Enumeration aliases = ks.aliases(); while (aliases.hasMoreElements()) { final String alias = (String) aliases.nextElement(); final Certificate cert = ks.getCertificate(alias); if (cert != null && cs.match(cert)) { return new SimpleKeySelectorResult(cert.getPublicKey()); } } return null; } /** * Searches the specified keystore for a certificate that matches the * specified X509Certificate and contains a public key that is compatible * with the specified SignatureMethod. * * @return a KeySelectorResult containing the cert's public key if there * is a match; otherwise null */ private KeySelectorResult certSelect(final X509Certificate xcert, final SignatureMethod sm) throws KeyStoreException { // skip non-signer certs final boolean[] keyUsage = xcert.getKeyUsage(); if (keyUsage[0] == false) { return null; } final String alias = ks.getCertificateAlias(xcert); if (alias != null) { final PublicKey pk = ks.getCertificate(alias).getPublicKey(); // make sure algorithm is compatible with method if (algEquals(sm.getAlgorithm(), pk.getAlgorithm())) { return new SimpleKeySelectorResult(pk); } } return null; } /** * Returns an OID of a public-key algorithm compatible with the specified * signature algorithm URI. */ private String getPKAlgorithmOID(final String algURI) { if (algURI.equalsIgnoreCase(SignatureMethod.DSA_SHA1)) { return "1.2.840.10040.4.1"; } else if (algURI.equalsIgnoreCase(SignatureMethod.RSA_SHA1)) { return "1.2.840.113549.1.1"; } else { return null; } } /** * A simple KeySelectorResult containing a public key. */ private static class SimpleKeySelectorResult implements KeySelectorResult { private final Key key; SimpleKeySelectorResult(final Key key) { this.key = key; } @Override public Key getKey() { return key; } } /** * Checks if a JCA/JCE public key algorithm name is compatible with * the specified signature algorithm URI. */ //@@@FIXME: this should also work for key types other than DSA/RSA private boolean algEquals(final String algURI, final String algName) { if (algName.equalsIgnoreCase("DSA") && algURI.equalsIgnoreCase(SignatureMethod.DSA_SHA1)) { return true; } else if (algName.equalsIgnoreCase("RSA") && algURI.equalsIgnoreCase(SignatureMethod.RSA_SHA1)) { return true; } else { return false; } } /** * Searches the specified keystore for a certificate that matches an * entry of the specified X509Data and contains a public key that is * compatible with the specified SignatureMethod. * * @return a KeySelectorResult containing the cert's public key if there * is a match; otherwise null */ private KeySelectorResult x509DataSelect(final X509Data xd, final SignatureMethod sm) throws KeyStoreException, KeySelectorException { // convert signature algorithm to compatible public-key alg OID final String algOID = getPKAlgorithmOID(sm.getAlgorithm()); KeySelectorResult ksr = null; final Iterator xi = xd.getContent().iterator(); while (xi.hasNext()) { ksr = null; final Object o = xi.next(); // check X509Certificate if (o instanceof X509Certificate) { final X509Certificate xcert = (X509Certificate) o; ksr = certSelect(xcert, sm); // check X509IssuerSerial } else if (o instanceof X509IssuerSerial) { final X509IssuerSerial xis = (X509IssuerSerial) o; final X509CertSelector xcs = new X509CertSelector(); try { xcs.setSubjectPublicKeyAlgID(algOID); xcs.setSerialNumber(xis.getSerialNumber()); xcs.setIssuer(new X500Principal (xis.getIssuerName()).getName()); } catch (IOException ioe) { throw new KeySelectorException(ioe); } ksr = keyStoreSelect(xcs); // check X509SubjectName } else if (o instanceof String) { final String sn = (String) o; final X509CertSelector xcs = new X509CertSelector(); try { xcs.setSubjectPublicKeyAlgID(algOID); xcs.setSubject(new X500Principal(sn).getName()); } catch (IOException ioe) { throw new KeySelectorException(ioe); } ksr = keyStoreSelect(xcs); // check X509SKI } else if (o instanceof byte[]) { final byte[] ski = (byte[]) o; final X509CertSelector xcs = new X509CertSelector(); try { xcs.setSubjectPublicKeyAlgID(algOID); } catch (IOException ioe) { throw new KeySelectorException(ioe); } // DER-encode ski - required by X509CertSelector final byte[] encodedSki = new byte[ski.length + 2]; encodedSki[0] = 0x04; // OCTET STRING tag value encodedSki[1] = (byte) ski.length; // length System.arraycopy(ski, 0, encodedSki, 2, ski.length); xcs.setSubjectKeyIdentifier(encodedSki); ksr = keyStoreSelect(xcs); // check X509CRL // not supported: should use CertPath API } else { // skip all other entries continue; } if (ksr != null) { return ksr; } } return null; } public static void main(final String[] args) throws Exception { } } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/utils/000077500000000000000000000000001406641055200272535ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/utils/Buffer.java000077500000000000000000000017251406641055200313370ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.utils; public interface Buffer { int TRANSFER_SIZE = 16 * 1024; // 16 KB } crypto-java-crypto-java-1.8.0/src/main/java/ro/kuberam/libs/java/crypto/utils/HexString.java000077500000000000000000000030061406641055200320330ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.utils; public class HexString { public static String fromBytes(final byte[] data) { final StringBuilder buf = new StringBuilder(); for (int i = 0; i < data.length; i++) { int halfbyte = (data[i] >>> 4) & 0x0F; int two_halfs = 0; do { if ((0 <= halfbyte) && (halfbyte <= 9)) { buf.append((char) ('0' + halfbyte)); } else { buf.append((char) ('a' + (halfbyte - 10))); } halfbyte = data[i] & 0x0F; } while (two_halfs++ < 1); } return buf.toString(); } } crypto-java-crypto-java-1.8.0/src/main/resources/000077500000000000000000000000001406641055200217445ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/resources/changelog.txt000077500000000000000000000044631406641055200244460ustar00rootroot000000000000000.2.3 Feature #145: Investigate which of the module files can be automatically generated from spec Feature #146: Property 'project.version' from module build file to be extracted from spec Feature #185: Release EXPath Cryptographic Module as xar 0.2.2 Feature #134: Automatically generate the error messages Java class from spec Feature #135: Separate eXist specific code for XML digital signature generation class Feature #136: Separate eXist specific code for XML digital signature validation class Feature #138: Add JUnit unit test for XML signature validation Feature #139: Add JUnit unit test for XML signature generation 0.2.1 Feature #128: Investigate about the output encoding for crypto:hmac() and crypto:hash(); currently is hex string Feature #129: Adapt the algorithm names in examples to the implementation's Java crypto providers (for instance, from HMAC-SHA-256 to HmacSHA256 ) Feature #130: Replace hard-coded error messages Feature #131: Replace the eXist XML Serializer used to validate a digital signature 0.2.0 Feature #122: Add crypto:hash() according to EXPath Crypto spec Feature #123: Align crypto:hmac() with EXPath Crypto spec Feature #124: Align crypto:encrypt() with EXPath Crypto spec Feature #125: Align crypto:decrypt() with EXPath Crypto spec Feature #126: Align crypto:generate-signature() with EXPath Crypto spec Feature #127: Align crypto:validate-signature() with EXPath Crypto spec Version 0.1.6 - 2012.01.01 1. Improvement of the test suite. Version 0.1.5 - 2011.05.01 1. Was added function hmac(), for hashing input strings. Version 0.1.4 - 2011.04.21 1. Project's namespace changed from "http://kuberam.ro/x-crypt" to "http://kuberam.ro/ns/x-crypt". 2. Added encrypt-string() and decrypt-string() functions, which works for now only for symmetric encryption/decryption. Version 0.1.3 - 2011.01.18 1. Improvements of XML serialization. 2. The function "validate-signature" validates only signatures generated without X.509 certificate. Version 0.1.2 - 2011.01.17 1. The function "generate-signature" allows now the sign a XML document based on an XPath expression. Version 0.1.1 - 2011.01.11 1. Added function "generate-signature" based on an X509 certificate. 2. Added function "validate-signature". Version 0.1.0 - 2011.01.10 1. First version. Contains "generate-signature" based on generated key pair.crypto-java-crypto-java-1.8.0/src/main/resources/ro/000077500000000000000000000000001406641055200223645ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/resources/ro/kuberam/000077500000000000000000000000001406641055200240125ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/resources/ro/kuberam/libs/000077500000000000000000000000001406641055200247435ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/resources/ro/kuberam/libs/java/000077500000000000000000000000001406641055200256645ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/resources/ro/kuberam/libs/java/crypto/000077500000000000000000000000001406641055200272045ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/main/resources/ro/kuberam/libs/java/crypto/lib.properties000077500000000000000000000000341406641055200320700ustar00rootroot00000000000000lib-version="${pom.version}"crypto-java-crypto-java-1.8.0/src/test/000077500000000000000000000000001406641055200177655ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/000077500000000000000000000000001406641055200207065ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/000077500000000000000000000000001406641055200213265ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/000077500000000000000000000000001406641055200227545ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/000077500000000000000000000000001406641055200237055ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/000077500000000000000000000000001406641055200246265ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/000077500000000000000000000000001406641055200261465ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/CryptoModuleTests.java000077500000000000000000000035361406641055200324740ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import static java.nio.charset.StandardCharsets.UTF_8; import java.io.IOException; import java.net.URISyntaxException; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; public class CryptoModuleTests { protected static String longString = "Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests."; protected static String veryLongString; protected static byte[] longInputBytes = longString.getBytes(UTF_8); protected static String sunProvider = "SunJCE"; protected static Path rsaPrivateKeyFile = Paths.get("rsa-private-key.key").toAbsolutePath(); protected static Path rsaPublicKeyFile = Paths.get("rsa-public-key.key").toAbsolutePath(); static { try { veryLongString = new String( Files.readAllBytes(Paths.get(CryptoModuleTests.class.getResource("very-long-string.txt").toURI())), UTF_8); } catch (IOException | URISyntaxException e) { e.printStackTrace(); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/ParametersTest.java000077500000000000000000000061161406641055200317630ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import org.junit.Test; import static org.junit.Assert.assertEquals; import static org.junit.Assert.fail; public class ParametersTest { @Test public void testCanonicalizationAlgorithmWrongValue() { final Parameters parameters = new Parameters(); try { parameters.setCanonicalizationAlgorithm("inclusive-with-commentss"); fail("Algorithm should have been unknown"); } catch (CryptoException e) { assertEquals(CryptoError.NoSuchAlgorithmException, e.getCryptoError()); } } @Test public void testCanonicalizationAlgorithmDefaultValue() { final Parameters parameters = new Parameters(); assertEquals("http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments", parameters.getCanonicalizationAlgorithm()); } @Test public void testDigestAlgorithmWrongValue() { final Parameters parameters = new Parameters(); try { parameters.setDigestAlgorithm("SHA1008"); fail("Algorithm should have been unknown"); } catch (CryptoException e) { assertEquals(CryptoError.NoSuchAlgorithmException, e.getCryptoError()); } } @Test public void testDigestAlgorithmDefaultValue() { final Parameters parameters = new Parameters(); assertEquals("http://www.w3.org/2000/09/xmldsig#sha1", parameters.getDigestAlgorithm()); } @Test public void testSignatureAlgorithmWrongValue() { final Parameters parameters = new Parameters(); try { parameters.setSignatureAlgorithm("RSA_SHA1008"); fail("Algorithm should have been unknown"); } catch (CryptoException e) { assertEquals(CryptoError.NoSuchAlgorithmException, e.getCryptoError()); } } @Test public void testSignatureAlgorithmDefaultValue() { final Parameters parameters = new Parameters(); assertEquals("http://www.w3.org/2000/09/xmldsig#rsa-sha1", parameters.getSignatureAlgorithm()); } @Test public void testSignatureNamespacePrefixDefaultValue() { final Parameters parameters = new Parameters(); assertEquals("dsig", parameters.getSignatureNamespacePrefix()); } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/PipedIOApp.java000077500000000000000000000064201406641055200307500ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import java.io.IOException; import java.io.PipedInputStream; import java.io.PipedOutputStream; public class PipedIOApp { public static void main(final String args[]) { final Thread thread1 = new Thread(new PipeOutput("Producer")); final Thread thread2 = new Thread(new PipeInput("Consumer")); thread1.start(); thread2.start(); boolean thread1IsAlive = true; boolean thread2IsAlive = true; do { if (thread1IsAlive && !thread1.isAlive()) { thread1IsAlive = false; } if (thread2IsAlive && !thread2.isAlive()) { thread2IsAlive = false; } } while (thread1IsAlive || thread2IsAlive); } } class PipeIO { static final PipedOutputStream outputPipe = new PipedOutputStream(); static final PipedInputStream inputPipe = new PipedInputStream(); static { try { outputPipe.connect(inputPipe); } catch (IOException ex) { System.out.println("IOException in static initializer"); } } String name; public PipeIO(final String id) { name = id; } } class PipeOutput extends PipeIO implements Runnable { public PipeOutput(final String id) { super(id); } @Override public void run() { final String s = "This is a test."; try { for (int i = 0; i < s.length(); ++i) { outputPipe.write(s.charAt(i)); System.out.println(name + " wrote " + s.charAt(i)); } outputPipe.write('!'); } catch (IOException ex) { System.out.println("IOException in PipeOutput"); } } } class PipeInput extends PipeIO implements Runnable { public PipeInput(final String id) { super(id); } @Override public void run() { boolean eof = false; try { while (!eof) { final int inChar = inputPipe.read(); if (inChar != -1) { char ch = (char) inChar; if (ch == '!') { eof = true; break; } else { System.out.println(name + " read " + ch); } } } } catch (IOException ex) { System.out.println("IOException in PipeOutput"); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/PipedInputStreamExample.java000077500000000000000000000055431406641055200335740ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.InputStream; import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; /** * Java PipedInputStream example * shows how to read bytes in one Java thread * sent by PipedOutputStream object from another Java thread */ /* * Receiver thread class - reads bytes from the stream */ class ReceiverThread extends Thread { private final DataInputStream in; public ReceiverThread(final InputStream is) { in = new DataInputStream(is); } @Override public void run() { //Reading data from the stream try { System.out.println(in.readDouble() + " " + in.readChar() + " " + in.readInt()); } catch (Exception e) { e.printStackTrace(); } } } /* * Producer thread class - sends bytes data to the stream */ class SenderThread extends Thread { private final DataOutputStream out; public SenderThread(final OutputStream os) { out = new DataOutputStream(os); } @Override public void run() { //Writing data to the stream try { out.writeDouble(123.45); out.writeChar('c'); out.writeInt(67); } catch (Exception e) { e.printStackTrace(); } } } public class PipedInputStreamExample { public static void main(final String[] args) throws Exception { try (final PipedOutputStream pos = new PipedOutputStream(); final PipedInputStream pis = new PipedInputStream(pos)) { final SenderThread senderThread = new SenderThread(pos); final ReceiverThread receiverThread = new ReceiverThread(pis); senderThread.start(); //send data to the piped stream receiverThread.start();//read data from the same piped stream //wait for all threads to finish senderThread.join(); receiverThread.join(); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/TestUtils.java000066400000000000000000000060601406641055200307530ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import org.w3c.dom.Document; import org.xml.sax.InputSource; import org.xml.sax.SAXException; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import java.io.*; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardOpenOption; import java.util.Arrays; public class TestUtils { private final static int SIXTEEN_KB = 16 * 1024; private final static int FIVE_MB = 5 * 1024 * 1024; private static final byte[] SIXTEEN_KB_DATA; static { SIXTEEN_KB_DATA = new byte[SIXTEEN_KB]; // 16KB buffer Arrays.fill(SIXTEEN_KB_DATA, (byte) '1'); // fill with the character '1' } private static final String FIVE_MB_DATA_STRING; static { final char[] FIVE_MB_DATA = new char[FIVE_MB]; Arrays.fill(FIVE_MB_DATA, '1'); // fill with the character '1' FIVE_MB_DATA_STRING = new String(FIVE_MB_DATA); } public static Path generate5MbFile(final File file) throws IOException { return generate5MbFile(file.toPath()); } public static Path generate5MbFile(final Path file) throws IOException { try (final OutputStream os = Files.newOutputStream(file, StandardOpenOption.TRUNCATE_EXISTING)) { final int iterations = FIVE_MB / SIXTEEN_KB; for (int i = 0; i < iterations; i++) { os.write(SIXTEEN_KB_DATA); } } return file; } public static String generate5MbString() { return FIVE_MB_DATA_STRING; } public static Document parseXmlString(final String xmlString) throws IOException { final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance(); documentBuilderFactory.setNamespaceAware(true); try (final Reader reader = new StringReader(xmlString)) { final InputSource is = new InputSource(reader); final DocumentBuilder db = documentBuilderFactory.newDocumentBuilder(); return db.parse(is); } catch (final SAXException | ParserConfigurationException e) { throw new IOException(e); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/UtilsTest.java000077500000000000000000000164011406641055200307560ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.ObjectOutputStream; import java.io.OutputStream; import java.io.PipedInputStream; import java.io.PipedOutputStream; import java.math.BigInteger; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.security.DigestOutputStream; import java.security.MessageDigest; import java.util.UUID; import org.apache.commons.io.IOUtils; import org.junit.ClassRule; import org.junit.Ignore; import org.junit.Test; import com.fasterxml.uuid.Generators; import com.fasterxml.uuid.impl.NameBasedGenerator; import org.junit.rules.TemporaryFolder; public class UtilsTest extends CryptoModuleTests { @ClassRule public static final TemporaryFolder temporaryFolder = new TemporaryFolder(); @Test public void pipedStreams1Test() throws Exception { final String message = "String for tests."; try (final PipedInputStream in = new PipedInputStream(); final PipedOutputStream outp = new PipedOutputStream(in)) { new Thread(() -> { try { outp.write(message.getBytes(StandardCharsets.UTF_8)); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }).start(); System.out.println("result: " + in); } } @Ignore @Test public void pipedStreams2Test() throws Exception { try (final InputStream document = getClass().getResourceAsStream("../doc-1.xml"); final ByteArrayOutputStream bos = new ByteArrayOutputStream()) { int next = document.read(); while (next > -1) { bos.write(next); next = document.read(); } bos.flush(); final byte[] result = bos.toByteArray(); try (final PipedOutputStream poStream = new PipedOutputStream(); final PipedInputStream piStream = new PipedInputStream()) { // piped input stream connect to the piped output stream piStream.connect(poStream); // Writes specified byte array. poStream.write(result); // Reads the next byte of data from this piped input stream. for (int i = 0; i < result.length; i++) { System.out.println(piStream.read()); } } } } @Test public void digestOutputStreamTest() throws Exception { final MessageDigest md = MessageDigest.getInstance("SHA-512"); try (final OutputStream fos = Files.newOutputStream(temporaryFolder.newFile("string.txt").toPath()); final DigestOutputStream dos = new DigestOutputStream(fos, md); final ObjectOutputStream oos = new ObjectOutputStream(dos) ) { final String data = "This have I thought good to deliver thee, " + "that thou mightst not lose the dues of rejoicing " + "by being ignorant of what greatness is promised thee."; oos.writeObject(data); dos.on(false); final byte[] digest = md.digest(); oos.writeObject(digest); final int digestLength = digest.length; System.out.println("length: " + digestLength); final BigInteger bi = new BigInteger(1, digest); String result = bi.toString(digestLength); if (result.length() % 2 != 0) { result = "0" + result; } System.out.println("result: " + result); } } public InputStream openStream() throws IOException { final PipedOutputStream out = new PipedOutputStream(); final PipedInputStream in = new PipedInputStream(out); final Runnable exporter = () -> { try { out.write("message".getBytes(StandardCharsets.UTF_8)); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } IOUtils.closeQuietly(out); }; // executor.submit(exporter); return in; } @Test public void uuid5Test() throws Exception { final String seed = "www.widgets.com"; final NameBasedGenerator uuid_gen_dns = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_DNS); final UUID uuid_dns = uuid_gen_dns.generate(seed); System.out.println("uuid_dns: " + uuid_dns); final NameBasedGenerator uuid_gen_oid = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_OID); final UUID uuid_oid = uuid_gen_oid.generate(seed); System.out.println("uuid_oid: " + uuid_oid); final NameBasedGenerator uuid_gen_url = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_URL); final UUID uuid_url = uuid_gen_url.generate(seed); System.out.println("uuid_url: " + uuid_url); final NameBasedGenerator uuid_gen_x500 = Generators.nameBasedGenerator(NameBasedGenerator.NAMESPACE_X500); final UUID uuid_x500 = uuid_gen_x500.generate(seed); System.out.println("uuid_x500: " + uuid_x500); } @Test public void uuid5NewTest() throws Exception { final String NameSpace_OID_string = "6ba7b812-9dad-11d1-80b4-00c04fd430c8"; final UUID NameSpace_OID_uuid = UUID.fromString(NameSpace_OID_string); final long msb = NameSpace_OID_uuid.getMostSignificantBits(); final long lsb = NameSpace_OID_uuid.getLeastSignificantBits(); final byte[] NameSpace_OID_buffer = new byte[16]; for (int i = 0; i < 8; i++) { NameSpace_OID_buffer[i] = (byte) (msb >>> 8 * (7 - i)); } for (int i = 8; i < 16; i++) { NameSpace_OID_buffer[i] = (byte) (lsb >>> 8 * (7 - i)); } final String name = "user123"; final byte[] name_buffer = name.getBytes(); try (final ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) { outputStream.write(NameSpace_OID_buffer); outputStream.write(name_buffer); final byte byteArray[] = outputStream.toByteArray(); System.out.println(UUID.nameUUIDFromBytes(byteArray).toString()); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/000077500000000000000000000000001406641055200274255ustar00rootroot00000000000000GenerateAWSSignatureTest.java000077500000000000000000000057151406641055200350530ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import java.nio.charset.StandardCharsets; import jakarta.xml.bind.DatatypeConverter; import org.junit.Test; import static org.junit.Assert.assertEquals; public class GenerateAWSSignatureTest { @Test public void hmacStringWithSha256() throws Exception { final String key = "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"; final String dateStamp = "20120215"; final String regionName = "us-east-1"; final String serviceName = "iam"; final String kSecret = "AWS4" + key; final String kSecretHexValue = DatatypeConverter.printHexBinary(kSecret.getBytes(StandardCharsets.UTF_8)) .toLowerCase(); assertEquals("41575334774a616c725855746e46454d492f4b374d44454e472b62507852666943594558414d504c454b4559", kSecretHexValue); final byte[] kDate = Hmac.hmac(dateStamp.getBytes(StandardCharsets.UTF_8), kSecret.getBytes(StandardCharsets.UTF_8), "HMAC-SHA-256"); final String kDateHexValue = generateHexValue(kDate); assertEquals("969fbb94feb542b71ede6f87fe4d5fa29c789342b0f407474670f0c2489e0a0d", kDateHexValue); final byte[] kRegion = Hmac.hmac(regionName.getBytes(StandardCharsets.UTF_8), kDate, "HMAC-SHA-256"); String kRegionHexValue = generateHexValue(kRegion); assertEquals("69daa0209cd9c5ff5c8ced464a696fd4252e981430b10e3d3fd8e2f197d7a70c", kRegionHexValue); final byte[] kService = Hmac.hmac(serviceName.getBytes(StandardCharsets.UTF_8), kRegion, "HMAC-SHA-256"); String kServiceHexValue = generateHexValue(kService); assertEquals("f72cfd46f26bc4643f06a11eabb6c0ba18780c19a8da0c31ace671265e3c87fa", kServiceHexValue); final byte[] kSigning = Hmac.hmac("aws4_request".getBytes(StandardCharsets.UTF_8), kService, "HMAC-SHA-256"); String kSigningHexValue = generateHexValue(kSigning); assertEquals("f4780e2d9f65fa895f9c67b32ce1baf0b0d8a43505a000a1a9e090d414db404d", kSigningHexValue); } private String generateHexValue(byte[] hexValue) { return DatatypeConverter.printHexBinary(hexValue).toLowerCase(); } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/HMACBinaryTest.java000066400000000000000000000106321406641055200330070ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.apache.commons.io.IOUtils; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.Collection; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @RunWith(Parameterized.class) public class HMACBinaryTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "hmac-md5-default", "HMAC-MD5", null, "qos0Wi3v2UmUINvZxUjlfw==" }, { "hmac-md5-base64", "HMAC-MD5", "base64", "qos0Wi3v2UmUINvZxUjlfw==" }, { "hmac-md5-hex", "HMAC-MD5", "hex", "aa8b345a2defd9499420dbd9c548e57f" }, { "hmac-sha1-default", "HMAC-SHA-1", null, "PQ35fW3zSlpw5l9t+dlc4Uuw4yw=" }, { "hmac-sha1-base64", "HMAC-SHA-1", "base64", "PQ35fW3zSlpw5l9t+dlc4Uuw4yw=" }, { "hmac-sha1-hex", "HMAC-SHA-1", "hex", "3d0df97d6df34a5a70e65f6df9d95ce14bb0e32c" }, { "hmac-sha256-default", "HMAC-SHA-256", null, "B+4Sajr34uDevILQascNd7wWh7hl/rSIHmXFbzmkxs0=" }, { "hmac-sha256-base64", "HMAC-SHA-256", "base64", "B+4Sajr34uDevILQascNd7wWh7hl/rSIHmXFbzmkxs0=" }, { "hmac-sha256-hex", "HMAC-SHA-256", "hex", "07ee126a3af7e2e0debc82d06ac70d77bc1687b865feb4881e65c56f39a4c6cd" }, { "hmac-sha384-default", "HMAC-SHA-384", null, "M2ZLLFCj2z+lUTtYFkjpKCIFVrCW+Z6rm369t2CF5rQJfiQM8BeXskpl/mRvwLiR" }, { "hmac-sha384-base64", "HMAC-SHA-384", "base64", "M2ZLLFCj2z+lUTtYFkjpKCIFVrCW+Z6rm369t2CF5rQJfiQM8BeXskpl/mRvwLiR" }, { "hmac-sha384-hex", "HMAC-SHA-384", "hex", "33664b2c50a3db3fa5513b581648e928220556b096f99eab9b7ebdb76085e6b4097e240cf01797b24a65fe646fc0b891" }, { "hmac-sha512-default", "HMAC-SHA-512", null, "m4wf0sXN0CUH4LuTWnrz+OlF3y2O4TPY1grp8Z3JKK+jzu340L1+UBVV3dSiKa/phSTb97FBpCjwQTBKbAs8Cw==" }, { "hmac-sha512-base64", "HMAC-SHA-512", "base64", "m4wf0sXN0CUH4LuTWnrz+OlF3y2O4TPY1grp8Z3JKK+jzu340L1+UBVV3dSiKa/phSTb97FBpCjwQTBKbAs8Cw==" }, { "hmac-sha512-hex", "HMAC-SHA-512", "hex", "9b8c1fd2c5cdd02507e0bb935a7af3f8e945df2d8ee133d8d60ae9f19dc928afa3ceedf8d0bd7e501555ddd4a229afe98524dbf7b141a428f041304a6c0b3c0b" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @Test public void hmacBinary() throws IOException, CryptoException { try (final InputStream input = getClass().getResourceAsStream("../keystore.ks"); final InputStream secretKeyIs = getClass().getResourceAsStream("../rsa-private-key.key")) { assertNotNull(input); final String result = Hmac.hmac(input, IOUtils.toByteArray(secretKeyIs), algorithm, format); assertEquals(expected, result); } } } HMACLargeBinaryTest.java000066400000000000000000000113751406641055200337100ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.junit.BeforeClass; import org.junit.ClassRule; import org.junit.Test; import org.junit.rules.TemporaryFolder; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.util.Arrays; import java.util.Collection; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertEquals; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbFile; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbString; @RunWith(Parameterized.class) public class HMACLargeBinaryTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "hmac-md5-default", "HMAC-MD5", null, "YOIFbIFlb9lfrwpzoF8lzw==" }, { "hmac-md5-base64", "HMAC-MD5", "base64", "YOIFbIFlb9lfrwpzoF8lzw==" }, { "hmac-md5-hex", "HMAC-MD5", "hex", "60e2056c81656fd95faf0a73a05f25cf" }, { "hmac-sha1-default", "HMAC-SHA-1", null, "5oQ7eaxyCwKP6utsj9kngm0sj90=" }, { "hmac-sha1-base64", "HMAC-SHA-1", "base64", "5oQ7eaxyCwKP6utsj9kngm0sj90=" }, { "hmac-sha1-hex", "HMAC-SHA-1", "hex", "e6843b79ac720b028feaeb6c8fd927826d2c8fdd" }, { "hmac-sha256-default", "HMAC-SHA-256", null, "bouSmXr9knkcpCWsWLhVVjEqq/TZOWJmam+gvf9LPFk=" }, { "hmac-sha256-base64", "HMAC-SHA-256", "base64", "bouSmXr9knkcpCWsWLhVVjEqq/TZOWJmam+gvf9LPFk=" }, { "hmac-sha256-hex", "HMAC-SHA-256", "hex", "6e8b92997afd92791ca425ac58b85556312aabf4d93962666a6fa0bdff4b3c59" }, { "hmac-sha384-default", "HMAC-SHA-384", null, "BBzLFaQammdp4BlanF/TKnIXt1mW56vz3imLcGOGNLRf6khRF8nsseQKpvt6W4Cx" }, { "hmac-sha384-base64", "HMAC-SHA-384", "base64", "BBzLFaQammdp4BlanF/TKnIXt1mW56vz3imLcGOGNLRf6khRF8nsseQKpvt6W4Cx" }, { "hmac-sha384-hex", "HMAC-SHA-384", "hex", "041ccb15a41a9a6769e0195a9c5fd32a7217b75996e7abf3de298b70638634b45fea485117c9ecb1e40aa6fb7a5b80b1" }, { "hmac-sha512-default", "HMAC-SHA-512", null, "qE1L1nxv9vY6elfkfCaZEOXD1M8lYZ0FhA0h0tMZ56Ec769enwam/RCJ3kfkJRP1TWglMSgwyquSd68pO9SAJg==" }, { "hmac-sha512-base64", "HMAC-SHA-512", "base64", "qE1L1nxv9vY6elfkfCaZEOXD1M8lYZ0FhA0h0tMZ56Ec769enwam/RCJ3kfkJRP1TWglMSgwyquSd68pO9SAJg==" }, { "hmac-sha512-hex", "HMAC-SHA-512", "hex", "a84d4bd67c6ff6f63a7a57e47c269910e5c3d4cf25619d05840d21d2d319e7a11cefaf5e9f06a6fd1089de47e42513f54d6825312830caab9277af293bd48026" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @ClassRule public static final TemporaryFolder temporaryFolder = new TemporaryFolder(); private static Path largeFile; @BeforeClass public static void setup() throws IOException { largeFile = generate5MbFile(temporaryFolder.newFile("hmacLargeBinary")); } @Test public void hmacLargeBinary_inputStream() throws IOException, CryptoException { try(final InputStream is = Files.newInputStream(largeFile)) { final String secretKey = "/hWLmb8xRM75bOS6fyV9Pn0mf3Aiw+HphRCL8nOq"; final String result = Hmac.hmac(is, secretKey.getBytes(UTF_8), algorithm, format); assertEquals(expected, result); } } } HMACLargeStringTest.java000066400000000000000000000102351406641055200337240ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.util.Arrays; import java.util.Collection; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertEquals; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbString; @RunWith(Parameterized.class) public class HMACLargeStringTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "hmac-md5-default", "HMAC-MD5", null, "YOIFbIFlb9lfrwpzoF8lzw==" }, { "hmac-md5-base64", "HMAC-MD5", "base64", "YOIFbIFlb9lfrwpzoF8lzw==" }, { "hmac-md5-hex", "HMAC-MD5", "hex", "60e2056c81656fd95faf0a73a05f25cf" }, { "hmac-sha1-default", "HMAC-SHA-1", null, "5oQ7eaxyCwKP6utsj9kngm0sj90=" }, { "hmac-sha1-base64", "HMAC-SHA-1", "base64", "5oQ7eaxyCwKP6utsj9kngm0sj90=" }, { "hmac-sha1-hex", "HMAC-SHA-1", "hex", "e6843b79ac720b028feaeb6c8fd927826d2c8fdd" }, { "hmac-sha256-default", "HMAC-SHA-256", null, "bouSmXr9knkcpCWsWLhVVjEqq/TZOWJmam+gvf9LPFk=" }, { "hmac-sha256-base64", "HMAC-SHA-256", "base64", "bouSmXr9knkcpCWsWLhVVjEqq/TZOWJmam+gvf9LPFk=" }, { "hmac-sha256-hex", "HMAC-SHA-256", "hex", "6e8b92997afd92791ca425ac58b85556312aabf4d93962666a6fa0bdff4b3c59" }, { "hmac-sha384-default", "HMAC-SHA-384", null, "BBzLFaQammdp4BlanF/TKnIXt1mW56vz3imLcGOGNLRf6khRF8nsseQKpvt6W4Cx" }, { "hmac-sha384-base64", "HMAC-SHA-384", "base64", "BBzLFaQammdp4BlanF/TKnIXt1mW56vz3imLcGOGNLRf6khRF8nsseQKpvt6W4Cx" }, { "hmac-sha384-hex", "HMAC-SHA-384", "hex", "041ccb15a41a9a6769e0195a9c5fd32a7217b75996e7abf3de298b70638634b45fea485117c9ecb1e40aa6fb7a5b80b1" }, { "hmac-sha512-default", "HMAC-SHA-512", null, "qE1L1nxv9vY6elfkfCaZEOXD1M8lYZ0FhA0h0tMZ56Ec769enwam/RCJ3kfkJRP1TWglMSgwyquSd68pO9SAJg==" }, { "hmac-sha512-base64", "HMAC-SHA-512", "base64", "qE1L1nxv9vY6elfkfCaZEOXD1M8lYZ0FhA0h0tMZ56Ec769enwam/RCJ3kfkJRP1TWglMSgwyquSd68pO9SAJg==" }, { "hmac-sha512-hex", "HMAC-SHA-512", "hex", "a84d4bd67c6ff6f63a7a57e47c269910e5c3d4cf25619d05840d21d2d319e7a11cefaf5e9f06a6fd1089de47e42513f54d6825312830caab9277af293bd48026" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @Test public void hmacLargeBinary_inputStream() throws CryptoException { final String input = generate5MbString(); final String secretKey = "/hWLmb8xRM75bOS6fyV9Pn0mf3Aiw+HphRCL8nOq"; final String result = Hmac.hmac(input.getBytes(UTF_8), secretKey.getBytes(UTF_8), algorithm, format); assertEquals(expected, result); } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/HMACStringTest.java000066400000000000000000000115201406641055200330260ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.apache.commons.io.IOUtils; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; import java.util.Arrays; import java.util.Collection; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertEquals; @RunWith(Parameterized.class) public class HMACStringTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "hmac-md5-default", "HMAC-MD5", null, "itnbgVvBCBqOareTyzTz0w==" }, { "hmac-md5-base64", "HMAC-MD5", "base64", "itnbgVvBCBqOareTyzTz0w==" }, { "hmac-md5-hex", "HMAC-MD5", "hex", "8ad9db815bc1081a8e6ab793cb34f3d3" }, { "hmac-sha1-default", "HMAC-SHA-1", null, "nUXjFZOV3d/7v+s4dTrbEqTzld8=" }, { "hmac-sha1-base64", "HMAC-SHA-1", "base64", "nUXjFZOV3d/7v+s4dTrbEqTzld8=" }, { "hmac-sha1-hex", "HMAC-SHA-1", "hex", "9d45e3159395dddffbbfeb38753adb12a4f395df" }, { "hmac-sha256-default", "HMAC-SHA-256", null, "YhJ2cHr8vmIXeS5AwVLq921i1lAZ1MyjTReC/ek8Yaw=" }, { "hmac-sha256-base64", "HMAC-SHA-256", "base64", "YhJ2cHr8vmIXeS5AwVLq921i1lAZ1MyjTReC/ek8Yaw=" }, { "hmac-sha256-hex", "HMAC-SHA-256", "hex", "621276707afcbe6217792e40c152eaf76d62d65019d4cca34d1782fde93c61ac" }, { "hmac-sha384-default", "HMAC-SHA-384", null, "I89ANhNIxCc44IsbpfT+v9bClNTat7zlG3NWNy95M4X+1KYF6Njadcpzyocqsbik" }, { "hmac-sha384-base64", "HMAC-SHA-384", "base64", "I89ANhNIxCc44IsbpfT+v9bClNTat7zlG3NWNy95M4X+1KYF6Njadcpzyocqsbik" }, { "hmac-sha384-hex", "HMAC-SHA-384", "hex", "23cf40361348c42738e08b1ba5f4febfd6c294d4dab7bce51b7356372f793385fed4a605e8d8da75ca73ca872ab1b8a4" }, { "hmac-sha512-default", "HMAC-SHA-512", null, "pI/CNSAbX55+U5gYPSe+mGYr1dbvnBM10Kmd6VIGANGKXPA73UuL8JcX0CcESqke9n4PJLgZulaEyJvb/zx6NA==" }, { "hmac-sha512-base64", "HMAC-SHA-512", "base64", "pI/CNSAbX55+U5gYPSe+mGYr1dbvnBM10Kmd6VIGANGKXPA73UuL8JcX0CcESqke9n4PJLgZulaEyJvb/zx6NA==" }, { "hmac-sha512-hex", "HMAC-SHA-512", "hex", "a48fc235201b5f9e7e5398183d27be98662bd5d6ef9c1335d0a99de9520600d18a5cf03bdd4b8bf09717d027044aa91ef67e0f24b819ba5684c89bdbff3c7a34" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @Test public void hmacString() throws IOException, CryptoException { final String input = "Short string for tests."; try (final InputStream secretKeyIs = getClass().getResourceAsStream("../rsa-private-key.key")) { final String result = Hmac.hmac(input.getBytes(StandardCharsets.UTF_8), IOUtils.toByteArray(secretKeyIs), algorithm, format); assertEquals(expected, result); } } @Test public void hmacString_inputStream() throws IOException, CryptoException { final String input = "Short string for tests."; try (final InputStream is = new ByteArrayInputStream(input.getBytes(UTF_8)); final InputStream secretKeyIs = getClass().getResourceAsStream("../rsa-private-key.key")) { final String result = Hmac.hmac(is, IOUtils.toByteArray(secretKeyIs), algorithm, format); assertEquals(expected, result); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/HashBinaryTest.java000066400000000000000000000076431406641055200331720ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.Collection; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; @RunWith(Parameterized.class) public class HashBinaryTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "md5-default", "md5", null, "UI/aOJodA6gtJPitQ6xcJA==" }, { "md5-base64", "md5", "base64", "UI/aOJodA6gtJPitQ6xcJA==" }, { "md5-hex", "md5", "hex", "508fda389a1d03a82d24f8ad43ac5c24" }, { "sha1-default", "sha1", null, "GyscHvnJKxInsBLgSg/FRAmQXYU=" }, { "sha1-base64", "sha1", "base64", "GyscHvnJKxInsBLgSg/FRAmQXYU=" }, { "sha1-hex", "sha1", "hex", "1b2b1c1ef9c92b1227b012e04a0fc54409905d85" }, { "sha256-default", "sha-256", null, "37JiNBym250ye3aUJ04RaZg3SFSP03qJ8FR/I1JckVI=" }, { "sha256-base64", "sha-256", "base64", "37JiNBym250ye3aUJ04RaZg3SFSP03qJ8FR/I1JckVI=" }, { "sha256-hex", "sha-256", "hex", "dfb262341ca6db9d327b7694274e1169983748548fd37a89f0547f23525c9152" }, { "sha384-default", "sha-384", null, "DcQ3caBftiQCIQn96Pr8PC2vzs17Re0tZ8/CZnOoucu/N+818uqAXxR7l9oxYgoW" }, { "sha384-base64", "sha-384", "base64", "DcQ3caBftiQCIQn96Pr8PC2vzs17Re0tZ8/CZnOoucu/N+818uqAXxR7l9oxYgoW" }, { "sha384-hex", "sha-384", "hex", "0dc43771a05fb624022109fde8fafc3c2dafcecd7b45ed2d67cfc26673a8b9cbbf37ef35f2ea805f147b97da31620a16" }, { "sha512-default", "sha-512", null, "Be+hlGy9TNibbaE+6DA2gu6kNj2GS+7b4egFcJDMzQSFQiGgFtTh/mD61ta4pDvc+jqHFlqOyJLHirkROd86Mw==" }, { "sha512-base64", "sha-512", "base64", "Be+hlGy9TNibbaE+6DA2gu6kNj2GS+7b4egFcJDMzQSFQiGgFtTh/mD61ta4pDvc+jqHFlqOyJLHirkROd86Mw==" }, { "sha512-hex", "sha-512", "hex", "05efa1946cbd4cd89b6da13ee8303682eea4363d864beedbe1e8057090cccd04854221a016d4e1fe60fad6d6b8a43bdcfa3a87165a8ec892c78ab91139df3a33" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @Test public void hashBinary() throws IOException, CryptoException { try (final InputStream input = getClass().getResourceAsStream("../keystore.ks")) { assertNotNull(input); final String result = Hash.hashBinary(input, algorithm, format); assertEquals(expected, result); } } } HashBinaryWithWrongAlgorithmTest.java000077500000000000000000000045031406641055200366260ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.Collection; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoError; import ro.kuberam.libs.java.crypto.CryptoException; import org.junit.Test; import static org.junit.Assert.*; @RunWith(Parameterized.class) public class HashBinaryWithWrongAlgorithmTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "sha17-default", "sha17", null }, { "sha17-base64", "sha17", "base64" }, { "sha17-hex", "sha17", "hex" } }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Test public void hashBinaryWithWrongAlgorithm() throws IOException { try (final InputStream input = getClass().getResourceAsStream("../keystore.ks")) { assertNotNull(input); Hash.hashBinary(input, algorithm, format); fail("Algorithm: " + algorithm + " should have been unknown"); } catch (final CryptoException e) { assertEquals(CryptoError.NoSuchAlgorithmException, e.getCryptoError()); } } } HashLargeBinaryTest.java000066400000000000000000000105631406641055200340610ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.junit.BeforeClass; import org.junit.ClassRule; import org.junit.Test; import org.junit.rules.TemporaryFolder; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.util.Arrays; import java.util.Collection; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbFile; @RunWith(Parameterized.class) public class HashLargeBinaryTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "md5-default", "md5", null, "K1yRrTmUCeybQJtm9bsA+w==" }, { "md5-base64", "md5", "base64", "K1yRrTmUCeybQJtm9bsA+w==" }, { "md5-hex", "md5", "hex", "2b5c91ad399409ec9b409b66f5bb00fb" }, { "sha1-default", "sha1", null, "uAQkoKGLYGLI6SzhFfnCduRQ+kc=" }, { "sha1-base64", "sha1", "base64", "uAQkoKGLYGLI6SzhFfnCduRQ+kc=" }, { "sha1-hex", "sha1", "hex", "b80424a0a18b6062c8e92ce115f9c276e450fa47" }, { "sha256-default", "sha-256", null, "w+00W+EpLUqgksmRJxzbaqfG43PQi1ZsG/3nQrJLFy0=" }, { "sha256-base64", "sha-256", "base64", "w+00W+EpLUqgksmRJxzbaqfG43PQi1ZsG/3nQrJLFy0=" }, { "sha256-hex", "sha-256", "hex", "c3ed345be1292d4aa092c991271cdb6aa7c6e373d08b566c1bfde742b24b172d" }, { "sha384-default", "sha-384", null, "Z6eOj8Es6VhSN4dRCBESe+6V7AhdBAU+VKbrrCqN8CDa/erGPrzvntL4J+FFQqw7" }, { "sha384-base64", "sha-384", "base64", "Z6eOj8Es6VhSN4dRCBESe+6V7AhdBAU+VKbrrCqN8CDa/erGPrzvntL4J+FFQqw7" }, { "sha384-hex", "sha-384", "hex", "67a78e8fc12ce958523787510811127bee95ec085d04053e54a6ebac2a8df020dafdeac63ebcef9ed2f827e14542ac3b" }, { "sha512-default", "sha-512", null, "ZbG4+jqkEy7SFY5/6+nAhpZ3ShwxM4YPtrcOXTspD0HOOnlH8Dx0Us1gKgMVzAjhb/0kcLVapvBq9A58PjBT+w==" }, { "sha512-base64", "sha-512", "base64", "ZbG4+jqkEy7SFY5/6+nAhpZ3ShwxM4YPtrcOXTspD0HOOnlH8Dx0Us1gKgMVzAjhb/0kcLVapvBq9A58PjBT+w==" }, { "sha512-hex", "sha-512", "hex", "65b1b8fa3aa4132ed2158e7febe9c08696774a1c3133860fb6b70e5d3b290f41ce3a7947f03c7452cd602a0315cc08e16ffd2470b55aa6f06af40e7c3e3053fb" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @ClassRule public static final TemporaryFolder temporaryFolder = new TemporaryFolder(); private static Path largeFile; @BeforeClass public static void setup() throws IOException { largeFile = generate5MbFile(temporaryFolder.newFile("hashLargeBinary")); } @Test public void hashLargeBinary() throws IOException, CryptoException { try (final InputStream is = Files.newInputStream(largeFile)) { final String result = Hash.hashBinary(is, algorithm, format); assertEquals(expected, result); } } } HashLargeStringTest.java000066400000000000000000000074501406641055200341040ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.IOException; import java.util.Arrays; import java.util.Collection; import static org.junit.Assert.assertEquals; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbString; @RunWith(Parameterized.class) public class HashLargeStringTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "md5-default", "md5", null, "K1yRrTmUCeybQJtm9bsA+w==" }, { "md5-base64", "md5", "base64", "K1yRrTmUCeybQJtm9bsA+w==" }, { "md5-hex", "md5", "hex", "2b5c91ad399409ec9b409b66f5bb00fb" }, { "sha1-default", "sha1", null, "uAQkoKGLYGLI6SzhFfnCduRQ+kc=" }, { "sha1-base64", "sha1", "base64", "uAQkoKGLYGLI6SzhFfnCduRQ+kc=" }, { "sha1-hex", "sha1", "hex", "b80424a0a18b6062c8e92ce115f9c276e450fa47" }, { "sha256-default", "sha-256", null, "w+00W+EpLUqgksmRJxzbaqfG43PQi1ZsG/3nQrJLFy0=" }, { "sha256-base64", "sha-256", "base64", "w+00W+EpLUqgksmRJxzbaqfG43PQi1ZsG/3nQrJLFy0=" }, { "sha256-hex", "sha-256", "hex", "c3ed345be1292d4aa092c991271cdb6aa7c6e373d08b566c1bfde742b24b172d" }, { "sha384-default", "sha-384", null, "Z6eOj8Es6VhSN4dRCBESe+6V7AhdBAU+VKbrrCqN8CDa/erGPrzvntL4J+FFQqw7" }, { "sha384-base64", "sha-384", "base64", "Z6eOj8Es6VhSN4dRCBESe+6V7AhdBAU+VKbrrCqN8CDa/erGPrzvntL4J+FFQqw7" }, { "sha384-hex", "sha-384", "hex", "67a78e8fc12ce958523787510811127bee95ec085d04053e54a6ebac2a8df020dafdeac63ebcef9ed2f827e14542ac3b" }, { "sha512-default", "sha-512", null, "ZbG4+jqkEy7SFY5/6+nAhpZ3ShwxM4YPtrcOXTspD0HOOnlH8Dx0Us1gKgMVzAjhb/0kcLVapvBq9A58PjBT+w==" }, { "sha512-base64", "sha-512", "base64", "ZbG4+jqkEy7SFY5/6+nAhpZ3ShwxM4YPtrcOXTspD0HOOnlH8Dx0Us1gKgMVzAjhb/0kcLVapvBq9A58PjBT+w==" }, { "sha512-hex", "sha-512", "hex", "65b1b8fa3aa4132ed2158e7febe9c08696774a1c3133860fb6b70e5d3b290f41ce3a7947f03c7452cd602a0315cc08e16ffd2470b55aa6f06af40e7c3e3053fb" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @Test public void hashLargeString() throws IOException, CryptoException { final String result = Hash.hashString(generate5MbString(), algorithm, format); assertEquals(expected, result); } } HashPerformanceTest.java000077500000000000000000000110461406641055200341230ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import java.io.BufferedInputStream; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Path; import java.security.DigestInputStream; import java.security.MessageDigest; import org.junit.BeforeClass; import org.junit.ClassRule; import org.junit.Ignore; import org.junit.Test; import org.junit.rules.TemporaryFolder; import static org.junit.Assert.assertEquals; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbFile; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbString; public class HashPerformanceTest { @ClassRule public static final TemporaryFolder temporaryFolder = new TemporaryFolder(); private static Path tempFile; private static String tempString; @BeforeClass public static void initialize() throws IOException { tempFile = generate5MbFile(temporaryFolder.newFile("HashPerformanceTest")); tempString = generate5MbString(); } @Test public void digestInputStreamWithFileInputStreamTest() throws Exception { final MessageDigest algorithm = MessageDigest.getInstance("SHA"); try (final DigestInputStream dis = new DigestInputStream(Files.newInputStream(tempFile), algorithm)) { // read the file and update the hash calculation while (dis.read() != -1) ; // get the hash value as byte array byte[] hash = algorithm.digest(); assertEquals(20, hash.length); } } @Test public void digestInputStreamWithBufferedInputStreamTest() throws Exception { final MessageDigest algorithm = MessageDigest.getInstance("SHA"); try (final BufferedInputStream bis = new BufferedInputStream(Files.newInputStream(tempFile)); final DigestInputStream dis = new DigestInputStream(bis, algorithm)) { // read the file and update the hash calculation while (dis.read() != -1) ; // get the hash value as byte array final byte[] hash = algorithm.digest(); assertEquals(20, hash.length); } } @Test public void digestStringWithInputStreamTest() throws Exception { MessageDigest algorithm = MessageDigest.getInstance("SHA"); try (final InputStream is = new ByteArrayInputStream(tempString.getBytes(StandardCharsets.UTF_8)); final DigestInputStream dis = new DigestInputStream(is, algorithm)) { // read the file and update the hash calculation while (dis.read() != -1) ; // get the hash value as byte array final byte[] hash = algorithm.digest(); assertEquals(20, hash.length); } } @Test public void digestString() throws Exception { final MessageDigest algorithm = MessageDigest.getInstance("SHA"); algorithm.update(tempString.getBytes(StandardCharsets.UTF_8)); final byte[] hash = algorithm.digest(); assertEquals(20, hash.length); } @Test @Ignore("too slow") public void digestWithByteArrayOutputStreamTest() throws Exception { final byte[] tempBa = Files.readAllBytes(tempFile); int tempByteArrayLength = tempBa.length; final MessageDigest algorithm = MessageDigest.getInstance("SHA"); while (tempByteArrayLength > 0) { algorithm.update(tempBa, 0, tempByteArrayLength); tempByteArrayLength = tempBa.length; } // get the hash value as byte array final byte[] hash = algorithm.digest(); assertEquals(20, hash.length); } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/HashStringTest.java000066400000000000000000000074011406641055200332040ustar00rootroot00000000000000/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.IOException; import java.util.Arrays; import java.util.Collection; import static org.junit.Assert.assertEquals; @RunWith(Parameterized.class) public class HashStringTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "md5-default", "md5", null, "use1oAoe8vIgnFgygz2OKw==" }, { "md5-base64", "md5", "base64", "use1oAoe8vIgnFgygz2OKw==" }, { "md5-hex", "md5", "hex", "bac7b5a00a1ef2f2209c5832833d8e2b" }, { "sha1-default", "sha1", null, "cV2wx17vo8eH2TaFRvCIIvJjNqU=" }, { "sha1-base64", "sha1", "base64", "cV2wx17vo8eH2TaFRvCIIvJjNqU=" }, { "sha1-hex", "sha1", "hex", "715db0c75eefa3c787d9368546f08822f26336a5" }, { "sha256-default", "sha-256", null, "E+B0JzLRgxm2+1rB8qIZoQ2Qn+JLxwJCWORv46fKhMM=" }, { "sha256-base64", "sha-256", "base64", "E+B0JzLRgxm2+1rB8qIZoQ2Qn+JLxwJCWORv46fKhMM=" }, { "sha256-hex", "sha-256", "hex", "13e0742732d18319b6fb5ac1f2a219a10d909fe24bc7024258e46fe3a7ca84c3" }, { "sha384-default", "sha-384", null, "F4CFDSBHm+Bm400bOgH2q2IbIUj8XRUBWf0inx7lrN0T8IHz9scGVmJoGZ2+s1La" }, { "sha384-base64", "sha-384", "base64", "F4CFDSBHm+Bm400bOgH2q2IbIUj8XRUBWf0inx7lrN0T8IHz9scGVmJoGZ2+s1La" }, { "sha384-hex", "sha-384", "hex", "1780850d20479be066e34d1b3a01f6ab621b2148fc5d150159fd229f1ee5acdd13f081f3f6c706566268199dbeb352da" }, { "sha512-default", "sha-512", null, "+YpeZRBrctlL1xr6plZOScp/6ArUw3GihjtKys1e3qQ6/aWLFjoOFEfuiUJA3uLIkebH1OG+rDdMFZ0+/JFK2g==" }, { "sha512-base64", "sha-512", "base64", "+YpeZRBrctlL1xr6plZOScp/6ArUw3GihjtKys1e3qQ6/aWLFjoOFEfuiUJA3uLIkebH1OG+rDdMFZ0+/JFK2g==" }, { "sha512-hex", "sha-512", "hex", "f98a5e65106b72d94bd71afaa6564e49ca7fe80ad4c371a2863b4acacd5edea43afda58b163a0e1447ee894240dee2c891e6c7d4e1beac374c159d3efc914ada" }, }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Parameterized.Parameter(value = 3) public String expected; @Test public void hashString() throws IOException, CryptoException { final String input = "Short string for tests."; final String result = Hash.hashString(input, algorithm, format); assertEquals(expected, result); } } HashStringWithWrongAlgorithmTest.java000077500000000000000000000043741406641055200366560ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digest/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 The EXPath Project * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digest; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import ro.kuberam.libs.java.crypto.CryptoError; import ro.kuberam.libs.java.crypto.CryptoException; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.Collection; import static org.junit.Assert.*; @RunWith(Parameterized.class) public class HashStringWithWrongAlgorithmTest { @Parameterized.Parameters(name = "{0}") public static Collection data() { return Arrays.asList(new Object[][] { { "sha17-default", "sha17", null }, { "sha17-base64", "sha17", "base64" }, { "sha17-hex", "sha17", "hex" } }); } @Parameterized.Parameter public String testTypeName; @Parameterized.Parameter(value = 1) public String algorithm; @Parameterized.Parameter(value = 2) public String format; @Test public void hashStringWithWrongAlgorithm() { try { final String input = "Short string for tests."; Hash.hashString(input, algorithm, format); fail("Algorithm: " + algorithm + " should have been unknown"); } catch (final CryptoException e) { assertEquals(CryptoError.NoSuchAlgorithmException, e.getCryptoError()); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digitalSignature/000077500000000000000000000000001406641055200314455ustar00rootroot00000000000000GenerateDigitalSignatureTest.java000077500000000000000000000153301406641055200400100ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.io.InputStream; import java.net.URI; import java.nio.file.Files; import java.nio.file.Paths; import java.security.InvalidAlgorithmParameterException; import java.security.KeyException; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmException; import java.security.PrivateKey; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; import javax.xml.crypto.MarshalException; import javax.xml.crypto.dom.DOMStructure; import javax.xml.crypto.dsig.Reference; import javax.xml.crypto.dsig.SignedInfo; import javax.xml.crypto.dsig.Transform; import javax.xml.crypto.dsig.XMLObject; import javax.xml.crypto.dsig.XMLSignature; import javax.xml.crypto.dsig.XMLSignatureException; import javax.xml.crypto.dsig.XMLSignatureFactory; import javax.xml.crypto.dsig.dom.DOMSignContext; import javax.xml.crypto.dsig.keyinfo.KeyInfo; import javax.xml.crypto.dsig.keyinfo.KeyInfoFactory; import javax.xml.crypto.dsig.keyinfo.KeyValue; import javax.xml.crypto.dsig.spec.C14NMethodParameterSpec; import javax.xml.crypto.dsig.spec.TransformParameterSpec; import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.ParserConfigurationException; import org.junit.Ignore; import org.junit.Test; import org.w3c.dom.Document; import org.w3c.dom.bootstrap.DOMImplementationRegistry; import org.w3c.dom.ls.DOMImplementationLS; import org.w3c.dom.ls.LSSerializer; import ro.kuberam.libs.java.crypto.Parameters; import static org.junit.Assert.assertEquals; import static java.nio.charset.StandardCharsets.UTF_8; public class GenerateDigitalSignatureTest { @Ignore @Test public void generateEnvelopedDigitalSignature() throws Exception { final Parameters parameters = new Parameters(); parameters.setSignatureType("enveloping"); final List data = new ArrayList<>(); final DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance(); final DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder(); final Document doc1 = docBuilder.parse(Paths.get( "src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature/doc-1.xml").toFile()); data.add(doc1); final Document doc2 = docBuilder.parse(Paths.get( "src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature/doc-2.xml").toFile()); data.add(doc2); final Document doc3 = docBuilder.parse(Paths.get( "src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature/doc-3.xml").toFile()); data.add(doc3); final String result = generateXMLSignature(data, parameters); final URI expectedUri = getClass().getResource("expected-digital-signature.xml").toURI(); final byte[] expectedData = Files.readAllBytes(Paths.get(expectedUri)); assertEquals(new String(expectedData, UTF_8), result); } private String generateXMLSignature(final List data, final Parameters parameters) throws NoSuchAlgorithmException, InvalidAlgorithmParameterException, KeyException, ParserConfigurationException, MarshalException, XMLSignatureException, InstantiationException, IllegalAccessException, ClassNotFoundException { final String keyPairAlgorithm = "RSA"; final XMLSignatureFactory sigFactory = XMLSignatureFactory.getInstance("DOM"); // create references final List references = new ArrayList<>(); final List xmlObjects = new ArrayList<>(); final Iterator iterator = data.iterator(); while (iterator.hasNext()) { final Document referencedObject = iterator.next(); final List transforms = Collections.singletonList(sigFactory.newTransform( Transform.ENVELOPED, (TransformParameterSpec) null)); final Reference reference = sigFactory.newReference("", sigFactory.newDigestMethod(parameters.getDigestAlgorithm(), null), transforms, null, null); references.add(reference); xmlObjects.add(sigFactory.newXMLObject( Collections.singletonList(new DOMStructure(referencedObject.getDocumentElement())), null, null, null)); } final SignedInfo si = sigFactory.newSignedInfo(sigFactory.newCanonicalizationMethod( parameters.getCanonicalizationAlgorithm(), (C14NMethodParameterSpec) null), sigFactory .newSignatureMethod(parameters.getSignatureAlgorithm(), null), references); // to be removed============================== final KeyPairGenerator kpg = KeyPairGenerator.getInstance(keyPairAlgorithm); kpg.initialize(512); final KeyPair kp = kpg.generateKeyPair(); final KeyInfoFactory kif = sigFactory.getKeyInfoFactory(); final KeyValue kv = kif.newKeyValue(kp.getPublic()); final KeyInfo ki = kif.newKeyInfo(Collections.singletonList(kv)); final PrivateKey privateKey = kp.getPrivate(); // to be removed============================== final DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); final Document doc = dbf.newDocumentBuilder().newDocument(); final DOMSignContext dsc = new DOMSignContext(privateKey, doc); final XMLSignature signature = sigFactory.newXMLSignature(si, ki, xmlObjects, null, null); signature.sign(dsc); final DOMImplementationRegistry registry = DOMImplementationRegistry.newInstance(); final DOMImplementationLS impl = (DOMImplementationLS) registry.getDOMImplementation("LS"); final LSSerializer serializer = impl.createLSSerializer(); return serializer.writeToString(doc); } } GenerateEnvelopedDigitalSignatureTest.java000077500000000000000000000047231406641055200416560ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertTrue; import static ro.kuberam.libs.java.crypto.TestUtils.parseXmlString; import java.io.IOException; import java.io.InputStream; import org.apache.commons.io.IOUtils; import org.junit.Test; import org.w3c.dom.Document; import ro.kuberam.libs.java.crypto.CryptoException; import javax.xml.crypto.dsig.XMLSignatureException; public class GenerateEnvelopedDigitalSignatureTest { @Test public void generateEnvelopedDigitalSignature() throws IOException, CryptoException, XMLSignatureException { try (final InputStream inputIs = getClass().getResourceAsStream("../doc-1.xml")) { final Document input = parseXmlString(IOUtils.toString(inputIs, UTF_8)); final String[] certificateDetails = new String[5]; certificateDetails[0] = ""; final String signatureString = GenerateXmlSignature.generate(input, "inclusive", "SHA1", "DSA_SHA1", "dsig", "enveloped", null, certificateDetails, null); System.out.println("signatureString=[" + signatureString + "]"); assertTrue( signatureString.contains("/KaCzo4Syrom78z3EQ5SbbB4sF7ey80etKII864WF64B81uRpH5t9jQTxeEu0ImbzRMqzVDZkVG9\nxD7nN1kuFw==") || signatureString.contains("/KaCzo4Syrom78z3EQ5SbbB4sF7ey80etKII864WF64B81uRpH5t9jQTxeEu0ImbzRMqzVDZkVG9 \nxD7nN1kuFw==") || signatureString.contains("/KaCzo4Syrom78z3EQ5SbbB4sF7ey80etKII864WF64B81uRpH5t9jQTxeEu0ImbzRMqzVDZkVG9 \nxD7nN1kuFw==")); } } } GenerateSignatureForStringTest.java000077500000000000000000000043201406641055200403450ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertEquals; import java.nio.file.Files; import java.nio.file.Paths; import java.security.PrivateKey; import org.junit.Test; import ro.kuberam.libs.java.crypto.keyManagement.Load; public class GenerateSignatureForStringTest { @Test public void JWT() throws Exception { String input = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0"; String sampleOutput = "POstGetfAytaZS82wHcjoTyoqhMyxXiWdR7Nn7A29DNSl0EiXLdwJ6xC6AfgZWF1bOsS_TuYI3OG85AmiExREkrS6tDfTQ2B3WXlrr-wp5AokiRbz3_oB4OxG-W9KcEEbDRcZc0nH3L7LzYptiy1PtAylQGxHTWZXtGz4ht0bAecBgmpdgXMguEIcoqPJ1n3pIWk_dUZegpqx0Lka21H6XxUTxiy8OcaarA8zdnPUnV6AmNP3ecFawIFYdvJB_cm-GvpCSbr8G8y_Mllj8f4x9nBH8pQux89_6gUY618iYv7tuPWBFfEbLxtF2pZS6YC1aSfLQxeNe8djT9YjpvRZA"; String algorithm = "RSA"; String base64PrivateKey = new String( Files.readAllBytes(Paths.get(getClass().getResource("../JWT-private-key.pkcs8").toURI())), UTF_8); PrivateKey privateKey = Load.privateKey(base64PrivateKey, algorithm, null); String output = SignatureForString.generate(input, privateKey, "SHA256withRSA"); output = output.replace("/", "_").replaceAll("=", "").replaceAll("\\+", "-"); assertEquals(output, sampleOutput); } } ValidateEnvelopedDigitalSignatureTest.java000077500000000000000000000041471406641055200416550ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/digitalSignature/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.digitalSignature; import java.io.IOException; import java.io.InputStream; import org.apache.commons.io.IOUtils; import org.junit.Test; import org.w3c.dom.Document; import ro.kuberam.libs.java.crypto.CryptoException; import javax.xml.crypto.dsig.XMLSignatureException; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertTrue; import static ro.kuberam.libs.java.crypto.TestUtils.parseXmlString; public class ValidateEnvelopedDigitalSignatureTest { @Test public void test() throws IOException, CryptoException, XMLSignatureException { try (final InputStream inputIs = getClass().getResourceAsStream("../doc-1.xml")) { final Document input = parseXmlString(IOUtils.toString(inputIs, UTF_8)); final String[] certificateDetails = new String[5]; certificateDetails[0] = ""; final String signatureString = GenerateXmlSignature.generate(input, "inclusive", "SHA1", "DSA_SHA1", "dsig", "enveloped", null, certificateDetails, null); final Document signature = parseXmlString(signatureString); final boolean validateSignature = ValidateXmlSignature.validate(signature); assertTrue(validateSignature); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/encrypt/000077500000000000000000000000001406641055200276325ustar00rootroot00000000000000AsymmetricEncryptionTest.java000077500000000000000000000071351406641055200354570ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/encrypt/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.encrypt; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertEquals; import java.nio.file.Files; import java.nio.file.Paths; import java.security.PrivateKey; import java.security.PublicKey; import org.junit.Ignore; import org.junit.Test; import ro.kuberam.libs.java.crypto.CryptoModuleTests; import ro.kuberam.libs.java.crypto.keyManagement.GenerateKeyPair; import ro.kuberam.libs.java.crypto.keyManagement.Load; public class AsymmetricEncryptionTest extends CryptoModuleTests { @Test public void encryptAndDecryptStringWithRsaAsymmetricKey() throws Exception { String transformation = "RSA/ECB/PKCS1Padding"; String algorithm = "RSA"; String base64PublicKey = new String( Files.readAllBytes(Paths.get(getClass().getResource("../rsa-public-key.key").toURI())), UTF_8); PublicKey publicKey = Load.publicKey(base64PublicKey, algorithm, null); String base64PrivateKey = new String( Files.readAllBytes(Paths.get(getClass().getResource("../rsa-private-key.key").toURI())), UTF_8); PrivateKey privateKey = Load.privateKey(base64PrivateKey, algorithm, null); String encryptedText = AsymmetricEncryption.encryptString(longString, publicKey, transformation); String decryptedText = AsymmetricEncryption.decryptString(encryptedText, privateKey, transformation); assertEquals(longString, decryptedText); } @Test public void adHocGeneratedKeyWithTheSameAlgorithm() throws Exception { String transformation = "RSA/ECB/PKCS1Padding"; String algorithm = "RSA"; final GenerateKeyPair.GeneratedKeys keys = GenerateKeyPair.run(algorithm); PublicKey publicKey = Load.publicKey(keys.getPublicKey(), algorithm, null); PrivateKey privateKey = Load.privateKey(keys.getPrivateKey(), algorithm, null); String encryptedText = AsymmetricEncryption.encryptString(longString, publicKey, transformation); String decryptedText = AsymmetricEncryption.decryptString(encryptedText, privateKey, transformation); assertEquals(longString, decryptedText); } @Ignore @Test public void adHocGeneratedKeyWithDifferentAlgorithm() throws Exception { String transformation = "RSA/ECB/PKCS1Padding"; String algorithm = "DSA"; String keyGenerationProvider = "SUN"; final GenerateKeyPair.GeneratedKeys keys = GenerateKeyPair.run(algorithm, keyGenerationProvider); PublicKey publicKey = Load.publicKey(keys.getPublicKey(), algorithm, keyGenerationProvider); PrivateKey privateKey = Load.privateKey(keys.getPrivateKey(), algorithm, keyGenerationProvider); String encryptedText = AsymmetricEncryption.encryptString(longString, publicKey, transformation); String decryptedText = AsymmetricEncryption.decryptString(encryptedText, privateKey, transformation); assertEquals(longString, decryptedText); } } SymmetricEncryptionTest.java000077500000000000000000000064521406641055200353170ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/encrypt/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.encrypt; import static java.nio.charset.StandardCharsets.UTF_8; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.BeforeClass; import org.junit.Ignore; import org.junit.Test; import ro.kuberam.libs.java.crypto.CryptoError; import ro.kuberam.libs.java.crypto.CryptoException; import ro.kuberam.libs.java.crypto.CryptoModuleTests; import ro.kuberam.libs.java.crypto.digest.Hash; public class SymmetricEncryptionTest extends CryptoModuleTests { private static String aesAlgorithmCbcMode = "AES/CBC/PKCS5Padding"; private static String aesAlgorithmEcbMode = "AES"; private static String key = "1234567890123456"; private static String wrongKey = "17"; private static String iv; @BeforeClass public static void beforeClassFunction() { try { iv = Hash.hashString("initialization vector", "MD5", "hex"); } catch (CryptoException e) { e.printStackTrace(); } } @Test public void aesAlgorithmAndDefaultProviderAndCbcMode() throws Exception { byte[] encryptionResult = SymmetricEncryption.encrypt(longInputBytes, key, aesAlgorithmCbcMode, iv, ""); byte[] decryptionResult = SymmetricEncryption.decrypt(encryptionResult, key, aesAlgorithmCbcMode, iv, ""); assertEquals(longString, new String(decryptionResult, UTF_8)); } @Test public void aesAlgorithmAndCbcMode() throws Exception { byte[] encryptionResult = SymmetricEncryption.encrypt(longInputBytes, key, aesAlgorithmCbcMode, iv, sunProvider); byte[] decryptionResult = SymmetricEncryption.decrypt(encryptionResult, key, aesAlgorithmCbcMode, iv, sunProvider); assertEquals(longString, new String(decryptionResult, UTF_8)); } @Test public void aesAlgorithmAndDefaultProviderAndEcbMode() throws Exception { byte[] encryptionResult = SymmetricEncryption.encrypt(longInputBytes, key, aesAlgorithmEcbMode, "", ""); byte[] decryptionResult = SymmetricEncryption.decrypt(encryptionResult, key, aesAlgorithmEcbMode, "", ""); assertEquals(longString, new String(decryptionResult, UTF_8)); } @Ignore @Test public void aesAlgorithmAndWrongKeyAndDefaultProviderAndCbcMode() throws IOException, CryptoException { try { byte[] encryptionResult = SymmetricEncryption.encrypt(longInputBytes, key, aesAlgorithmCbcMode, iv, ""); SymmetricEncryption.decrypt(encryptionResult, wrongKey, aesAlgorithmCbcMode, iv, ""); } catch (CryptoException e) { assertEquals(CryptoError.InvalidKeySpecException, e.getCryptoError()); } } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/keyManagement/000077500000000000000000000000001406641055200307335ustar00rootroot00000000000000DsaKeyGenerator.java000077500000000000000000000051301406641055200345500ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/keyManagement/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.keyManagement; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.PrivateKey; import java.security.PublicKey; import java.util.Base64; class DsaKeyGenerator { public static void main(String[] a) { int keySize = 1024; String output = "aa"; String algorithm = "DSA"; try { genKeyPair(keySize, output, algorithm); } catch (Exception e) { System.out.println("Exception: " + e); return; } } private static void genKeyPair(int keySize, String output, String algorithm) throws Exception { KeyPairGenerator kg = KeyPairGenerator.getInstance(algorithm, "SUN"); kg.initialize(keySize); System.out.println(); System.out.println("KeyPairGenerator Object Info: "); System.out.println("Algorithm = " + kg.getAlgorithm()); System.out.println("Provider = " + kg.getProvider()); System.out.println("Key Size = " + keySize); System.out.println("toString = " + kg.toString()); KeyPair pair = kg.generateKeyPair(); PrivateKey priKey = pair.getPrivate(); PublicKey pubKey = pair.getPublic(); byte[] ky = priKey.getEncoded(); System.out.println(); System.out.println("Private Key Info: "); System.out.println("Algorithm = " + priKey.getAlgorithm()); System.out.println("Size = " + ky.length); System.out.println("Format = " + priKey.getFormat()); System.out.println("toString = " + Base64.getEncoder().encodeToString(priKey.getEncoded())); System.out.println(); System.out.println("Public Key Info: "); System.out.println("Algorithm = " + pubKey.getAlgorithm()); System.out.println("Size = " + ky.length); System.out.println("Format = " + pubKey.getFormat()); System.out.println("toString = " + Base64.getEncoder().encodeToString(pubKey.getEncoded())); } }GenerateKeyPairTest.java000077500000000000000000000026771406641055200354150ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/keyManagement/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.keyManagement; import org.junit.Test; import static org.junit.Assert.*; public class GenerateKeyPairTest { @Test public void rsaKeyPair() throws Exception { final GenerateKeyPair.GeneratedKeys keys = GenerateKeyPair.run("RSA"); assertNotNull(keys); assertNotNull(keys.getPrivateKey()); assertTrue(keys.getPrivateKey().matches("-----BEGIN RSA PRIVATE KEY-----\n[^-]+-----END RSA PRIVATE KEY-----\n")); assertNotNull(keys.getPublicKey()); assertTrue(keys.getPublicKey().matches("-----BEGIN RSA PUBLIC KEY-----\n[^-]+-----END RSA PUBLIC KEY-----\n")); } } TranslateKeyTest.java000077500000000000000000000031221406641055200347660ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/keyManagement/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.keyManagement; import org.junit.Test; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; public class TranslateKeyTest { @Test public void rsaKeyPair() throws Exception { String algorithm = "DSA"; String keyGenerationProvider = "SUN"; final GenerateKeyPair.GeneratedKeys keys = GenerateKeyPair.run(algorithm, keyGenerationProvider); assertNotNull(keys); assertNotNull(keys.getPrivateKey()); assertTrue(keys.getPrivateKey().matches("-----BEGIN DSA PRIVATE KEY-----\n[^-]+-----END DSA PRIVATE KEY-----\n")); assertNotNull(keys.getPublicKey()); assertTrue(keys.getPublicKey().matches("-----BEGIN DSA PUBLIC KEY-----\n[^-]+-----END DSA PUBLIC KEY-----\n")); } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/providers/000077500000000000000000000000001406641055200301635ustar00rootroot00000000000000AddProviderTest.java000077500000000000000000000025311406641055200340160ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/providers/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; import javax.xml.stream.FactoryConfigurationError; import org.junit.Test; public class AddProviderTest { @Test public void addProvider() throws FactoryConfigurationError, Exception { final String input = "Short string for tests."; // String result2 = Hash.hashString(input, "SHA-256", "BC"); // // System.out.println(result2); // // Assert.assertTrue(result2 // .equals("E+B0JzLRgxm2+1rB8qIZoQ2Qn+JLxwJCWORv46fKhMM=")); } } ListAlgorithms.java000077500000000000000000000066571406641055200337350ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/providers/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; import java.security.Provider; import java.security.Security; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class ListAlgorithms { public static void printSet(String setName, Set algorithms) { System.out.println(setName + ":"); if (algorithms.isEmpty()) { System.out.println(" None available."); } else { Iterator it = algorithms.iterator(); while (it.hasNext()) { String name = (String) it.next(); System.out.println(" " + name); } } } public static void main(String[] args) { Provider[] providers = Security.getProviders(); Set ciphers = new HashSet(); Set keyAgreements = new HashSet(); Set macs = new HashSet(); Set messageDigests = new HashSet(); Set signatures = new HashSet(); Set keyFactory = new HashSet(); Set keyPairGenerator = new HashSet(); Set keyGenerator = new HashSet(); for (int i = 0; i != providers.length; i++) { Iterator it = providers[i].keySet().iterator(); while (it.hasNext()) { String entry = (String) it.next(); if (entry.startsWith("Alg.Alias.")) { entry = entry.substring("Alg.Alias.".length()); } if (entry.startsWith("Cipher.")) { ciphers.add(entry.substring("Cipher.".length())); } else if (entry.startsWith("KeyAgreement.")) { keyAgreements.add(entry.substring("KeyAgreement.".length())); } else if (entry.startsWith("Mac.")) { macs.add(entry.substring("Mac.".length())); } else if (entry.startsWith("MessageDigest.")) { messageDigests.add(entry.substring("MessageDigest.".length())); } else if (entry.startsWith("Signature.")) { signatures.add(entry.substring("Signature.".length())); } else if (entry.startsWith("KeyPairGenerator.")) { keyPairGenerator.add(entry.substring("KeyPairGenerator.".length())); } else if (entry.startsWith("KeyFactory.")) { keyFactory.add(entry.substring("KeyFactory.".length())); } else if (entry.startsWith("KeyGenerator.")) { keyGenerator.add(entry.substring("KeyGenerator.".length())); } else { System.out.println(entry); } } } printSet("KeyGenerator", keyGenerator); printSet("KeyFactory", keyFactory); printSet("KeyPairGenerator", keyPairGenerator); printSet("Ciphers", ciphers); printSet("KeyAgreeents", keyAgreements); printSet("Macs", macs); printSet("MessageDigests", messageDigests); printSet("Signatures", signatures); } }ListDSAProviderTest.java000077500000000000000000000027351406641055200345770ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/providers/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; import java.security.Provider; import java.security.Provider.Service; import org.junit.Test; import java.security.Security; import static org.junit.Assert.*; public class ListDSAProviderTest { @Test public void list() { final Provider[] providers = Security.getProviders(); assertNotNull(providers); assertTrue(providers.length > 1); boolean foundDsa = false; for (final Provider p : providers) { final Service s = p.getService("KeyPairGenerator", "DSA"); if (s != null) { foundDsa = true; } } assertTrue("JDK should always implement DSA", foundDsa); } } ListProvidersTest.java000077500000000000000000000041411406641055200344230ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/providers/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; import javax.xml.stream.FactoryConfigurationError; import javax.xml.transform.stream.StreamResult; import org.junit.Ignore; import org.junit.Test; import static org.junit.Assert.assertTrue; import java.security.Provider; import java.security.Security; import java.util.Iterator; import java.util.Set; public class ListProvidersTest { @Ignore @Test public void listProviders() throws FactoryConfigurationError, Exception { StreamResult providers = ListProviders.listProviders(); String providersString = providers.getWriter().toString(); assertTrue(providersString.contains("SunJCE")); } @Test public void listProviders2() throws FactoryConfigurationError { for (Provider provider : Security.getProviders()) { final Set keys = provider.keySet(); System.out.println(provider.getName()); System.out.println(" " + provider.getVersion()); System.out.println(" " + provider.getInfo()); for (Iterator it = keys.iterator(); it.hasNext();) { String key = (String) it.next(); key = key.split(" ")[0]; if (key.startsWith("Alg.Alias")) { // Strip the alias key = key.substring(10); } final int ix = key.indexOf('.'); //System.out.println("\t" + key); } } } } ListServicesTest.java000077500000000000000000000104261406641055200342340ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/providers/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.providers; import java.security.Provider; import java.security.Security; import java.util.Arrays; import java.util.HashSet; import java.util.Iterator; import java.util.Set; public class ListServicesTest { // @Test // public void listServices() throws XMLStreamException, // FactoryConfigurationError { // StreamResult providers = ListProviders.listProviders(); // String providersString = providers.getWriter().toString(); // System.out.println(providersString); // Assert.assertTrue(providersString.contains("base64")); // } private static String[] getServiceTypes() { Set result = new HashSet<>(); // All providers Provider[] providers = Security.getProviders(); for (int i = 0; i < providers.length; i++) { // Get services provided by each provider final Set keys = providers[i].keySet(); for (Iterator it = keys.iterator(); it.hasNext();) { String key = (String) it.next(); key = key.split(" ")[0]; if (key.startsWith("Alg.Alias")) { // Strip the alias key = key.substring(10); } int ix = key.indexOf('.'); result.add(key.substring(0, ix)); } } return result.toArray(new String[result.size()]); } /** * This method returns the available implementations for a given service type. * * @param serviceType * A String object that represents a particular service * type * @return String[] object that is a list of all available service type * implementations. */ private static String[] getCryptoImpls(String serviceType) { Set result = new HashSet<>(); // All providers Provider[] providers = Security.getProviders(); for (int i = 0; i < providers.length; i++) { // Get services provided by each provider Set keys = providers[i].keySet(); for (Iterator it = keys.iterator(); it.hasNext();) { String key = (String) it.next(); key = key.split(" ")[0]; if (key.startsWith(serviceType + ".")) { result.add(key.substring(serviceType.length() + 1)); } else if (key.startsWith("Alg.Alias." + serviceType + ".")) { // This is an alias result.add(key.substring(serviceType.length() + 11)); } } } return result.toArray(new String[result.size()]); } /** * Print all Service Types (sorted) to STDOUT. */ private static void listServiceTypes() { System.out.println(); System.out.println("Service Types"); System.out.println("-------------"); String[] serviceTypes = getServiceTypes(); Arrays.sort(serviceTypes); for (int i = 0; i < serviceTypes.length; i++) { System.out.println(" - " + serviceTypes[i]); } System.out.println(); } /** * Print all Service Type Implementations (sorted) to STDOUT. */ private static void listCryptoImpls() { System.out.println(); System.out.println("Service Type Implementations"); System.out.println("----------------------------"); String[] serviceTypes = getServiceTypes(); Arrays.sort(serviceTypes); for (int i = 0; i < serviceTypes.length; i++) { System.out.println(); System.out.println(" - " + serviceTypes[i]); String[] serviceTypeImpls = getCryptoImpls(serviceTypes[i]); Arrays.sort(serviceTypeImpls); for (int j = 0; j < serviceTypeImpls.length; j++) { System.out.println(" " + serviceTypeImpls[j]); } } System.out.println(); } public static void main(String[] args) { listServiceTypes(); listCryptoImpls(); } } crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/utils/000077500000000000000000000000001406641055200273065ustar00rootroot00000000000000ByteArray2HexStringPerformanceTest.java000077500000000000000000000205341406641055200367430ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/utils/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.utils; import java.io.IOException; import java.math.BigInteger; import java.nio.file.Files; import java.nio.file.Path; import java.util.Formatter; import jakarta.xml.bind.annotation.adapters.HexBinaryAdapter; import org.junit.BeforeClass; import org.junit.ClassRule; import org.junit.Ignore; import org.junit.Test; import org.junit.rules.TemporaryFolder; import static junit.framework.TestCase.assertEquals; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbFile; public class ByteArray2HexStringPerformanceTest { @ClassRule public static final TemporaryFolder temporaryFolder = new TemporaryFolder(); private static Path tempFile; private static byte[] tempByteArray; @BeforeClass public static void initialize() throws IOException { tempFile = generate5MbFile(temporaryFolder.newFile("ByteArray2HexStringPerformanceTest")); tempByteArray = Files.readAllBytes(tempFile); } @Test public void hexCharsTest() { final char[] HEX_CHARS = "0123456789abcdef".toCharArray(); final int tempByteArrayLength = tempByteArray.length; final char[] chars = new char[2 * tempByteArrayLength]; for (int i = 0; i < tempByteArrayLength; ++i) { chars[2 * i] = HEX_CHARS[(tempByteArray[i] & 0xF0) >>> 4]; chars[2 * i + 1] = HEX_CHARS[tempByteArray[i] & 0x0F]; } final String result = new String(chars); assertEquals(tempByteArrayLength * 2, result.length()); } @Test public void formatterTest() { final Formatter formatter = new Formatter(); for (final byte b : tempByteArray) { formatter.format("%02x", b); } final String result = formatter.toString(); assertEquals(tempByteArray.length * 2, result.length()); } @Test public void stringBuilderTest1() { final int tempByteArrayLength = tempByteArray.length; final StringBuilder strbuf = new StringBuilder(tempByteArrayLength * 2); for (int i = 0; i < tempByteArrayLength; i++) { if (((int) tempByteArray[i] & 0xff) < 0x10) { strbuf.append("0"); } strbuf.append(Long.toString((int) tempByteArray[i] & 0xff, 16)); } final String result = strbuf.toString(); assertEquals(tempByteArrayLength * 2, result.length()); } @Test public void stringBuilderTest2() { final StringBuilder sb = new StringBuilder(); for (final byte b : tempByteArray) { sb.append(Integer.toHexString((int) (b & 0xff))); } final String result = sb.toString(); assertEquals(tempByteArray.length * 2, result.length()); } @Test public void charArrayTest() { final char[] hexDigits = "0123456789abcdef".toCharArray(); final char[] byteToHexPair = new char[16 * 16 * 2]; for (int i = 0, o = 0; i < 256; ++i) { byteToHexPair[o++] = hexDigits[i >>> 4]; byteToHexPair[o++] = hexDigits[i & 15]; } final int tempByteArrayLength = tempByteArray.length; final char[] chars = new char[2 * tempByteArrayLength]; for (int i = 0, o = 0; i < tempByteArrayLength; ++i) { int index = tempByteArray[i]; chars[o++] = byteToHexPair[index++]; chars[o++] = byteToHexPair[index]; } final String result = new String(chars); assertEquals(tempByteArrayLength * 2, result.length()); } @Test public void hexArrayTest() { final int tempByteArrayLength = tempByteArray.length; final char[] hexArray = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; final char[] hexChars = new char[tempByteArrayLength * 2]; int v; for (int j = 0; j < tempByteArrayLength; j++) { v = tempByteArray[j] & 0xFF; hexChars[j * 2] = hexArray[v / 16]; hexChars[j * 2 + 1] = hexArray[v % 16]; } final String result = new String(hexChars); assertEquals(tempByteArrayLength * 2, result.length()); } @Test public void stringBuilder1Test() { final StringBuilder sb = new StringBuilder(); for (final byte b : tempByteArray) { sb.append(String.format("%1$02X", b)); } final String result = sb.toString(); assertEquals(tempByteArray.length * 2, result.length()); } @Test public void stringBuilder2Test() { final int tempByteArrayLength = tempByteArray.length; final StringBuilder sb = new StringBuilder(tempByteArrayLength * 2); for (final byte b : tempByteArray) { sb.append(Integer.toHexString(b + 0x800).substring(1)); } final String result = sb.toString(); assertEquals(tempByteArrayLength * 2, result.length()); } @Test public void stringBuilder3Test() { final int tempByteArrayLength = tempByteArray.length; final String digits = "0123456789abcdef"; final StringBuilder sb = new StringBuilder(tempByteArrayLength * 2); for (final byte b : tempByteArray) { int bi = b & 0xff; sb.append(digits.charAt(bi >> 4)); sb.append(digits.charAt(bi & 0xf)); } final String result = sb.toString(); assertEquals(tempByteArrayLength * 2, result.length()); } @Test public void stringBuilder4Test() { final int tempByteArrayLength = tempByteArray.length; final StringBuilder hexString = new StringBuilder(); for (int i = 0; i < tempByteArrayLength; i++) { final String hexByte = Integer.toHexString(0xFF & tempByteArray[i]); int numDigits = 2 - hexByte.length(); while (numDigits-- > 0) { hexString.append('0'); } hexString.append(hexByte); } final String result = hexString.toString(); assertEquals(tempByteArrayLength * 2, result.length()); } @Ignore @Test public void hexBinaryAdapterTest() { final String result = new HexBinaryAdapter().marshal(tempByteArray); assertEquals(tempByteArray.length, result.length()); } @Test public void integer2Test() { final int tempByteArrayLength = tempByteArray.length; final StringBuilder hexString = new StringBuilder(); for (int i = 0; i < tempByteArrayLength; i++) { final int temp = 0xFF & tempByteArray[i]; String s = Integer.toHexString(temp); if (temp <= 0x0F) { s = "0" + s; } hexString.append(s); } final String result = hexString.toString(); assertEquals(tempByteArrayLength * 2, result.length()); } @Test @Ignore("too slow, took hours and didn't finish") public void integer1Test() { final int tempByteArrayLengthQuartered = tempByteArray.length / 4; String result = ""; for (int i = 0; i < tempByteArrayLengthQuartered; i++) { final int ii = i * 4; final int inty = tempByteArray[ii] + tempByteArray[ii + 1] * 0xff + tempByteArray[ii + 2] * 0xffff + tempByteArray[ii + 3] * 0xffffff; result = Integer.toHexString(inty) + result; } assertEquals(tempByteArray.length, result.length()); } @Test @Ignore("too slow") public void stringFormatterTest() { final byte[] a = {0x40, 0x00, 0x39, 0x00}; final String result = String.format("%0128x", new BigInteger(1, tempByteArray)); } } InputStream2ByteArrayPerformanceTest.java000077500000000000000000000041771406641055200373100ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/utils/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.utils; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import org.junit.Before; import org.junit.ClassRule; import org.junit.Test; import org.junit.rules.TemporaryFolder; import static org.junit.Assert.assertEquals; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbFile; public class InputStream2ByteArrayPerformanceTest { @ClassRule public static final TemporaryFolder temporaryFolder = new TemporaryFolder(); private static Path tempFile; @Before public void initialize() throws IOException { tempFile = generate5MbFile(temporaryFolder.newFile("InputStream2ByteArrayPerformanceTest")); } @Test public void byteArrayOutputStreamTest() throws Exception { try (final InputStream is = Files.newInputStream(tempFile); final ByteArrayOutputStream baos = new ByteArrayOutputStream()) { int next = is.read(); while (next > -1) { baos.write(next); next = is.read(); } baos.flush(); final byte[] byteArray = baos.toByteArray(); assertEquals(5 * 1024 * 1024, byteArray.length); } } } String2InputStreamPerformanceTest.java000077500000000000000000000030071406641055200366430ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/java/ro/kuberam/libs/java/crypto/utils/* * EXPath Cryptographic Module * Java Library providing an EXPath Cryptographic Module * Copyright (C) 2015 Kuberam * * This 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 2.1 * of the License, or (at your option) any later version. * * This 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 this library; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package ro.kuberam.libs.java.crypto.utils; import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; import java.nio.charset.StandardCharsets; import org.junit.BeforeClass; import org.junit.Test; import static ro.kuberam.libs.java.crypto.TestUtils.generate5MbString; public class String2InputStreamPerformanceTest { private static String tempString; @BeforeClass public static void initialize() { tempString = generate5MbString(); } @Test public void test() throws IOException { try (final InputStream is = new ByteArrayInputStream(tempString.getBytes(StandardCharsets.UTF_8))) { } } } crypto-java-crypto-java-1.8.0/src/test/resources/000077500000000000000000000000001406641055200217775ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/000077500000000000000000000000001406641055200224175ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/000077500000000000000000000000001406641055200240455ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/000077500000000000000000000000001406641055200247765ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/000077500000000000000000000000001406641055200257175ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/000077500000000000000000000000001406641055200272375ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/JWT-private-key.pkcs8000077500000000000000000000032501406641055200331160ustar00rootroot00000000000000-----BEGIN PRIVATE KEY----- MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCfPKKzVmN80HRs GAoUxK++RO3CW8GxomrtLnAD6TN5U5WlVbCRZ1WFrizfxcz+lr/Kvjtq/v7PdVOa 8NHIAdxpP3bCFEQWku/1yPmVN4lKJvKv8yub9i2MJlVaBo5giHCtfAouo+v/XWKd awCR8jK28dZPFlgRxcuABcW5S5pLe4X2ASI1DDMZNTW/QWqSpMGvgHydbccI3jtd S7S3xjR76V/izg7FBrBYPv0n3/l3dHLS9tXcCbUW0YmIm87BGwh9UKEOlhK1NwdM Iyq29ZtXovXUFaSnMZdJbge/jepr4ZJg4PZBTrwxvn2hKTY4H4G04ukmh+ZsYQaC +bDIIj0zAgMBAAECggEAKIBGrbCSW2O1yOyQW9nvDUkA5EdsS58Q7US7bvM4iWpu DIBwCXur7/VuKnhn/HUhURLzj/JNozynSChqYyG+CvL+ZLy82LUE3ZIBkSdv/vFL Ft+VvvRtf1EcsmoqenkZl7aN7HD7DJeXBoz5tyVQKuH17WW0fsi9StGtCcUl+H6K zV9Gif0Kj0uLQbCg3THRvKuueBTwCTdjoP0PwaNADgSWb3hJPeLMm/yII4tIMGbO w+xd9wJRl+ZN9nkNtQMxszFGdKjedB6goYLQuP0WRZx+YtykaVJdM75bDUvsQar4 9Pc21Fp7UVk/CN11DX/hX3TmTJAUtqYADliVKkTbCQKBgQDLU48tBxm3g1CdDM/P ZIEmpA3Y/m7e9eX7M1Uo/zDh4G/S9a4kkX6GQY2dLFdCtOS8M4hR11Io7MceBKDi djorTZ5zJPQ8+b9Rm+1GlaucGNwRW0cQk2ltT2ksPmJnQn2xvM9T8vE+a4A/YGzw mZOfpoVGykWs/tbSzU2aTaOybQKBgQDIfRf6OmirGPh59l+RSuDkZtISF/51mCV/ S1M4DltWDwhjC2Y2T+meIsb/Mjtz4aVNz0EHB8yvn0TMGr94Uwjv4uBdpVSwz+xL hHL7J4rpInH+i0gxa0N+rGwsPwI8wJG95wLY+Kni5KCuXQw55uX1cqnnsahpRZFZ EerBXhjqHwKBgBmEjiaHipm2eEqNjhMoOPFBi59dJ0sCL2/cXGa9yEPA6Cfgv49F V0zAM2azZuwvSbm4+fXTgTMzrDW/PPXPArPmlOk8jQ6OBY3XdOrz48q+b/gZrYyO A6A9ZCSyW6U7+gxxds/BYLeFxF2v21xC2f0iZ/2faykv/oQMUh34en/tAoGACqVZ 2JexZyR0TUWf3X80YexzyzIq+OOTWicNzDQ29WLm9xtr2gZ0SUlfd72bGpQoyvDu awkm/UxfwtbIxALkvpg1gcN9s8XWrkviLyPyZF7H3tRWiQlBFEDjnZXa8I7pLkRO Cmdp3fp17cxTEeAI5feovfzZDH39MdWZuZrdh9ECgYBTEv8S7nK8wrxIC390kroV 52eBwzckQU2mWa0thUtaGQiU1EYPCSDcjkrLXwB72ft0dW57KyWtvrB6rt1ORgOL eI5hFbwdGQhCHTrAR1vG3SyFPMAm+8JB+sGOD/fvjtZKx//MFNweKFNEF0C/o6Z2 FXj90PlgF8sCQut36ZfuIQ== -----END PRIVATE KEY----- crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/JWT-private-key.txt000077500000000000000000000032121406641055200327030ustar00rootroot00000000000000-----BEGIN RSA PRIVATE KEY----- MIIEogIBAAKCAQEAnzyis1ZjfNB0bBgKFMSvvkTtwlvBsaJq7S5wA+kzeVOVpVWw kWdVha4s38XM/pa/yr47av7+z3VTmvDRyAHcaT92whREFpLv9cj5lTeJSibyr/Mr m/YtjCZVWgaOYIhwrXwKLqPr/11inWsAkfIytvHWTxZYEcXLgAXFuUuaS3uF9gEi NQwzGTU1v0FqkqTBr4B8nW3HCN47XUu0t8Y0e+lf4s4OxQawWD79J9/5d3Ry0vbV 3Am1FtGJiJvOwRsIfVChDpYStTcHTCMqtvWbV6L11BWkpzGXSW4Hv43qa+GSYOD2 QU68Mb59oSk2OB+BtOLpJofmbGEGgvmwyCI9MwIDAQABAoIBACiARq2wkltjtcjs kFvZ7w1JAORHbEufEO1Eu27zOIlqbgyAcAl7q+/1bip4Z/x1IVES84/yTaM8p0go amMhvgry/mS8vNi1BN2SAZEnb/7xSxbflb70bX9RHLJqKnp5GZe2jexw+wyXlwaM +bclUCrh9e1ltH7IvUrRrQnFJfh+is1fRon9Co9Li0GwoN0x0byrrngU8Ak3Y6D9 D8GjQA4Elm94ST3izJv8iCOLSDBmzsPsXfcCUZfmTfZ5DbUDMbMxRnSo3nQeoKGC 0Lj9FkWcfmLcpGlSXTO+Ww1L7EGq+PT3NtRae1FZPwjddQ1/4V905kyQFLamAA5Y lSpE2wkCgYEAy1OPLQcZt4NQnQzPz2SBJqQN2P5u3vXl+zNVKP8w4eBv0vWuJJF+ hkGNnSxXQrTkvDOIUddSKOzHHgSg4nY6K02ecyT0PPm/UZvtRpWrnBjcEVtHEJNp bU9pLD5iZ0J9sbzPU/LxPmuAP2Bs8JmTn6aFRspFrP7W0s1Nmk2jsm0CgYEAyH0X +jpoqxj4efZfkUrg5GbSEhf+dZglf0tTOA5bVg8IYwtmNk/pniLG/zI7c+GlTc9B BwfMr59EzBq/eFMI7+LgXaVUsM/sS4Ry+yeK6SJx/otIMWtDfqxsLD8CPMCRvecC 2Pip4uSgrl0MOebl9XKp57GoaUWRWRHqwV4Y6h8CgYAZhI4mh4qZtnhKjY4TKDjx QYufXSdLAi9v3FxmvchDwOgn4L+PRVdMwDNms2bsL0m5uPn104EzM6w1vzz1zwKz 5pTpPI0OjgWN13Tq8+PKvm/4Ga2MjgOgPWQkslulO/oMcXbPwWC3hcRdr9tcQtn9 Imf9n2spL/6EDFId+Hp/7QKBgAqlWdiXsWckdE1Fn91/NGHsc8syKvjjk1onDcw0 NvVi5vcba9oGdElJX3e9mxqUKMrw7msJJv1MX8LWyMQC5L6YNYHDfbPF1q5L4i8j 8mRex97UVokJQRRA452V2vCO6S5ETgpnad36de3MUxHgCOX3qL382Qx9/THVmbma 3YfRAoGAUxL/Eu5yvMK8SAt/dJK6FedngcM3JEFNplmtLYVLWhkIlNRGDwkg3I5K y18Ae9n7dHVueyslrb6weq7dTkYDi3iOYRW8HRkIQh06wEdbxt0shTzAJvvCQfrB jg/3747WSsf/zBTcHihTRBdAv6OmdhV4/dD5YBfLAkLrd+mX7iE= -----END RSA PRIVATE KEY-----digital-certificate-base64.txt000077500000000000000000000006211406641055200347020ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/cryptoPGRpZ2l0YWwtY2VydGlmaWNhdGU+DQogIDxrZXlzdG9yZS10eXBlPkpLUzwva2V5c3RvcmUtdHlw ZT4NCiAgPGtleXN0b3JlLXBhc3N3b3JkPmFiOTg3Yzwva2V5c3RvcmUtcGFzc3dvcmQ+DQogIDxr ZXktYWxpYXM+ZVhpc3Q8L2tleS1hbGlhcz4NCiAgPHByaXZhdGUta2V5LXBhc3N3b3JkPmtwaTEz NTwvcHJpdmF0ZS1rZXktcGFzc3dvcmQ+DQogIDxrZXlzdG9yZS11cmk+L3diPWUvdGVzdHMvZXhw YXRoLWNyeXB0by9yZXNvdXJjZXMva2V5c3RvcmU8L2tleXN0b3JlLXVyaT4NCjwvZGlnaXRhbC1j ZXJ0aWZpY2F0ZT4=crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/digital-certificate.xml000077500000000000000000000004421406641055200336610ustar00rootroot00000000000000 JKS ab987c eXist kpi135 /wb=e/tests/expath-crypto/resources/keystore crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature/000077500000000000000000000000001406641055200325365ustar00rootroot00000000000000doc-1.xml000077500000000000000000000001331406641055200341040ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature 1 7 doc-2.xml000077500000000000000000000001001406641055200340770ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature 1 doc-3.xml000077500000000000000000000000571406641055200341130ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature 7expected-digital-signature.xml000066400000000000000000000060061406641055200404160ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/digitalSignature<?xml version="1.0" encoding="UTF-16"?> <Signature xmlns="http://www.w3.org/2000/09/xmldsig#"><SignedInfo><CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315#WithComments"/><SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/><Reference URI=""><Transforms><Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/></Transforms><DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><DigestValue>2jmj7l5rSw0yVb/vlWAYkK/YBwk=</DigestValue></Reference><Reference URI=""><Transforms><Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/></Transforms><DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><DigestValue>2jmj7l5rSw0yVb/vlWAYkK/YBwk=</DigestValue></Reference><Reference URI=""><Transforms><Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/></Transforms><DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/><DigestValue>2jmj7l5rSw0yVb/vlWAYkK/YBwk=</DigestValue></Reference></SignedInfo><SignatureValue>Nmz3xb8DeOfZOYuqPq+0numQBBk331qzaHrtBYkpz3LvaXc37hXVIqgpMfqOUHvpAsGnsaW+mKu/ 0CNQDXtrrg==</SignatureValue><KeyInfo><KeyValue><RSAKeyValue><Modulus>gdzzWGqj0+aZdesAPDY65cXslUHevgPAgi8GQGBPML0Tw4SqBreBtgl+Ci/jh1KmXjclFelWyaX6 tiGj8kFVJQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue></KeyValue></KeyInfo><Object><data> <a>1</a> <b>7</b> <c/> <c/> </data></Object><Object><data> <a>1</a> </data></Object><Object><b>7</b></Object></Signature>crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/doc-1.xml000077500000000000000000000001331406641055200306640ustar00rootroot00000000000000 1 7 crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/keystore.ks000077500000000000000000000022451406641055200314510ustar00rootroot00000000000000exist--00 +*xa,^i߭|6RIJmv)x((17ˎd#kvՔHr5tm#b2[e_{Vj oy}/Z5Z *2:X JYF/1xjC ;Fhi~P9B>xd8TDilK0 *H8/0,f%9i.1s7{SAhxD-k29B5S43[ /crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/mycert.cer000077500000000000000000000012051406641055200312360ustar00rootroot00000000000000-----BEGIN CERTIFICATE----- MIIBqjCCARMCBgEteaBAlzANBgkqhkiG9w0BAQsFADAbMRkwFwYDVQQDExBUZXN0IENlcnRpZmlj YXRlMB4XDTExMDExMjA5NDczMVoXDTExMDExMjA5NDkxMVowGzEZMBcGA1UEAxMQVGVzdCBDZXJ0 aWZpY2F0ZTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnCl2ubpT4A7eebwvjHJWJUSBsVg7 zJA2GH9NxY5jVS7rQmEF3uPIzEIR1yhwg8WKqiEZ9hK6TFw3SyQ+u18K4AYZOtKwXmF3Gd3c9Lc9 X8/djRENZ6u2rLEIW9uZGjWxYlTxif2aBoLjJkBnF3z4/IPO7Q92W9St0WIh8ggK428CAwEAATAN BgkqhkiG9w0BAQsFAAOBgQAV2TNxFE3XJElZxtp09KLZAGkXyXWtzYdO/MAJebClBXmoL/6S5eRT JZlrOlr4U/LFq9G+HxI/vNtzEpQed1cF9r3XjrcZHq1YN2wHTBt04STVSnKCavY0MV8Rjy/+Rah5 tod8T9vPR0YkHJUPMaYp5EMTnG5U0qdlgbSvrZc4Dg== -----END CERTIFICATE----- crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/mykeystoreEXist.ks000077500000000000000000000022451406641055200327740ustar00rootroot00000000000000exist--00 +*xa,^i߭|6RIJmv)x((17ˎd#kvՔHr5tm#b2[e_{Vj oy}/Z5Z *2:X JYF/1xjC ;Fhi~P9B>xd8TDilK0 *H8/0,f%9i.1s7{SAhxD-k29B5S43[ /crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/rsa-private-key.key000077500000000000000000000015141406641055200330000ustar00rootroot00000000000000MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKAUZV+tjiNBKhlBZbKBnzeugpdYPhh5PbHanjV0aQ+LF7vetPYhbTiCVqA3a+Chmge44+prlqd3qQCYra6OYIe7oPVq4mETa1c/7IuSlKJgxC5wMqYKxYydb1eULkrs5IvvtNddx+9O/JlyM5sTPosgFHOzr4WqkVtQ71IkR+HrAgMBAAECgYAkQLo8kteP0GAyXAcmCAkA2Tql/8wASuTX9ITD4lsws/VqDKO64hMUKyBnJGX/91kkypCDNF5oCsdxZSJgV8owViYWZPnbvEcNqLtqgs7nj1UHuX9S5yYIPGN/mHL6OJJ7sosOd6rqdpg6JRRkAKUV+tmN/7Gh0+GFXM+ug6mgwQJBAO9/+CWpCAVoGxCA+YsTMb82fTOmGYMkZOAfQsvIV2v6DC8eJrSa+c0yCOTa3tirlCkhBfB08f8U2iEPS+Gu3bECQQCrG7O0gYmFL2RX1O+37ovyyHTbst4s4xbLW4jLzbSoimL235lCdIC+fllEEP96wPAiqo6dzmdH8KsGmVozsVRbAkB0ME8AZjp/9Pt8TDXD5LHzo8mlruUdnCBcIo5TMoRG2+3hRe1dHPonNCjgbdZCoyqjsWOiPfnQ2Brigvs7J4xhAkBGRiZUKC92x7QKbqXVgN9xYuq7oIanIM0nz/wq190uq0dh5Qtow7hshC/dSK3kmIEHe8z++tpoLWvQVgM538apAkBoSNfaTkDZhFavuiVl6L8cWCoDcJBItip8wKQhXwHp0O3HLg10OEd14M58ooNfpgt+8D8/8/2OOFaR0HzA+2Dmcrypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/rsa-public-key.key000077500000000000000000000003301406641055200325770ustar00rootroot00000000000000MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCgFGVfrY4jQSoZQWWygZ83roKXWD4YeT2x2p41dGkPixe73rT2IW04glagN2vgoZoHuOPqa5and6kAmK2ujmCHu6D1auJhE2tXP+yLkpSiYMQucDKmCsWMnW9XlC5K7OSL77TXXcfvTvyZcjObEz6LIBRzs6+FqpFbUO9SJEfh6wIDAQABcrypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/signatures/000077500000000000000000000000001406641055200314235ustar00rootroot00000000000000detached-signature.xml000077500000000000000000000024171406641055200356350ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/signatures descendant-or-self::Contract 1ybLCHRnYSGKCoswkUOuD650Mr0= descendant-or-self::FILLER 2jmj7l5rSw0yVb/vlWAYkK/YBwk= CBML9dFb/hEQXXR7oYfTuu4qit/VhUjwIfvPhSUQTQg0j+BFiTZFwNZaCJkZGswxDnSKhH1p CuLn/Fpzl2CJpNduDU0Ff0pstd7MITS0l0/IvhDVS+Tf6WiYkN8UYTCkJeg063zlbW+15mR1 Z25jCs0gWO9qESthX34qXRi7ii0= enveloped-enveloping-detached-signature.xml000077500000000000000000000045071406641055200417620ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/signatures testval1 testval2 IpBpovbT2WG7C+gTME1Np/V2fqo= pFXQ3ZZv4Fivm2MFs6vpfEanEDI= 7bPj9pPMJpsJw1OJ1b2jsrhxYMY= descendant-or-self::node1 2gFHdr03uDeDqwcxGveD+uYDIjM= descendant-or-self::node2 nn7t7PJs5RqDp1BKZ4j1BxhX2ik= Ui7XYcZNkXG+9OqNgKrcRJoyCuhpoRtVmFnXVOMf8aAuGXZw3FwFxz7VLKv9c1K8ZUNW9vCs G4 EpahlCS4AcpbVBwv00HvkhA11/tqYYB9kRK/wM4cb6sN5ULbQ4Ab0j9xyFKOQ6sr2MawOx fdNEes6XAHbpWZvxKDR4vWxAFnE= dGhpcyBpcyBhbiBpbnZhbGlkIHRlc3QgZG9jIGZvciB4bWwgZHNpZyBzZXJ2aWNlLgo= enveloped-signature.xml000077500000000000000000000053001406641055200360470ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/signatures testval1 testval2 XEZm5p6sjqi+Gt61BHQTOWtL2Nw= 1k1M9eAUMUWM4FP4OA1/YC9qS/Y= UmZlQ5g4ummBZu4IRg+BHDpZeeX4ix1GXODhyG+f5tvw+4ZDKIGn8qm5wdAj3+/wJS84Lx/ V hRgjyaucMjM3qEoMAEXEWYRTag0PdeOmfrSUffictYcTaGpPUYjDiWfKyFXAlCL5XmSeBW 5sMGgy5Bi/Y0HB1gwlmu+Jsh6FsGM= kFhwg4m9hjFmrlxVR3w0XmYx7fgGsoh+aelmXlzCug5gRV0t0XeSpaeoX1jXu6gacJ Vl/pOlNs+av+iviDKmS94LDPJtjAcl7C9dZbbt39N+/2S9WBAtJGXk5MOIu0aab50D UFK55m UbpsZzwoVQrisW+KArnWlbrUP5xWXsnwM= AQAB CommonName=serena_rsa,Country=SG,EmailAddress=serena_li@stercomm.com 1190704157 CommonName=serena_rsa,Country=SG,EmailAddress=serena_li@stercomm.com MIICBjCCAW8CBEb4tB0wDQYJKoZIhvcNAQEFBQAwSTElMCMGCSqGSIb3DQEJARYWc2VyZW 5hX2xp QHN0ZXJjb21tLmNvbTELMAkGA1UEBhMCU0cxEzARBgNVBAMTCnNlcmVuYV9yc2Ew IBcNMDcwOTI1 MDcwOTE3WhgPMjA2MjA2MjgwNzA5MTdaMEkxJTAjBgkqhk iG9w0BCQEWFnNlcmVuYV9saUBzdGVy Y29tbS5jb20xCzAJBgNVBAYTAlNHMRMwEQYDVQQDE wpzZXJlbmFfcnNhMIGfMA0GCSqGSIb3DQEB AQUAA4GNADCBiQKBgQCQWHCDib2GMWauXFVH fDReZjHt+AayiH5p6WZeXMK6DmBFXS3Rd5Klp6hf WNe7qBpwlWX+k6U2z 5q/6K+IMqZL3gsM8m2MByXsL11ltu3f037/ZL1YEC0kZeTkw4i7RppvnQNQ UrnmZRumxnPCh VCuKxb4oCudaVutQ/nFZeyfAwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAC+7glCs TKBSURkwmb A4k/SYVOOhhz3VkBX0he3r1/Vd6Qk8IlRJwQj5AT8e40gz+vqO0GvjaY Ax70bvIGqn yYE/VVJJOG5Zw6Tott69Dx4AOCrmbZb96zOAjlcEI3Ol7U1h+9+Uo2h5ZC8AMWn C3rk3VudrSB8dAhBwZmY9l8AB enveloping-signature-for-non-xml-file.xml000077500000000000000000000015051406641055200413260ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/signatures UWdFQL/JwoDirPg/AJdp+m5+bT4= cAtHLlmNUVRmWzn4mDvWkcRvFDoKOkes+gMsnC4pHAKclg99j+e2xxR0SsE5HnvNPEH3IrwT GZyaT XVlx3UTaX1C+215t0 mW4CYn4nyZpwJTbM18pRZq8tijquydg4roZz/yawz856uow3KH z+khzOuwt78GzwQXVyqQymyVrQk= dGhpcyBpcyB0ZXN0 enveloping-signature.xml000077500000000000000000000047361406641055200362500ustar00rootroot00000000000000crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/signatures mb5wQZvkO1C4+YzJUQ0Q2eL1nNg= cITL2XfG2q9roG/XpFaoa/JSiGU= Z6hxQRWv1+RZMU5UYIN06LmhFfGVtNIniIfeAmNy5TGX6SZAY5vgYbuhhZtq+LWG5nwzSQLX Kv7TIb8 N++LYgJeUtcwumCvI6t6rl6PJuSQiJZnucdpGxChrE1rra2WrRZYXxaLkoSUrBJc1 pCnXscU6F0eHmK akIV0ZypdFZT4= kFhwg4m9hjFmrlxVR3w0XmYx7fgGsoh+aelmXlzCug5gRV0t0XeSpaeoX1jXu6gacJ Vl/pOlNs+av+iviDKmS94LDPJtjAcl7C9dZbbt39N+/2S9WBAtJGXk5MOIu0aab50D UFK55mUbps ZzwoVQrisW+KArnWlbrUP5xWXsnwM= AQAB CommonName=serena_rsa,Country=SG,EmailAddress=serena_li@stercomm.com 1190704157 CommonName=serena_rsa,Country=SG,EmailAddress=serena_li@stercomm.com MIICBjCCAW8CBEb4tB0wDQYJKoZIhvcNAQEFBQAwSTElMCMGCSqGSIb3DQEJARYWc2VyZW5hX2xp QHN0 ZXJjb21tLmNvbTELMAkGA1UEBhMCU0cxEzARBgNVBAMTCnNlcmVuYV9yc2EwIBcNMDcwOTI1 MDcwOTE3 WhgPMjA2MjA2MjgwNzA5MTdaMEkxJTAjBgkqhkiG9w0BCQEWFnNlcmVuYV9saUBzdGVy Y29tbS5jb20x CzAJBgNVBAYTAlNHMRMwEQYDVQQDEwpzZXJlbmFfcnNhMIGfMA0GCSqGSIb3DQEB AQUAA4GNADCBiQKBg QCQWHCDib2GMWauXFVHfDReZjHt+AayiH5p6WZeXMK6DmBFXS3Rd5Klp6hf WNe7qBpwlWX+k6U2z5q/6K +IMqZL3gsM8m2MByXsL11ltu3f037/ZL1YEC0kZeTkw4i7RppvnQNQ UrnmZRumxnPChVCuKxb4oCudaVut Q/nFZeyfAwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAC+7glCs TKBSURkwmbA4k/SYVOOhhz3VkBX0he3r1/ Vd6Qk8IlRJwQj5AT8e40gz+vqO0GvjaYAx70bvIGqn yYE/VVJJOG5Zw6Tott69Dx4AOCrmbZb96zOAjlc EI3Ol7U1h+9+Uo2h5ZC8AMWnC3rk3VudrSB8dAhBwZmY9l8AB testval1 testval2 crypto-java-crypto-java-1.8.0/src/test/resources/ro/kuberam/libs/java/crypto/very-long-string.txt000077500000000000000000000263531406641055200332420ustar00rootroot00000000000000Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests. Long string for tests.