Fix the whole Javadoc syntax

2015-12-31 01:06:09 +01:00
parent 7f1ce66fd0
commit e1a84448a2
26 changed files with 1002 additions and 921 deletions
@@ -13,56 +13,57 @@
 // OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 package fr.xephi.authme.security.crypts;

-import fr.xephi.authme.ConsoleLogger;
-import fr.xephi.authme.security.crypts.description.HasSalt;
-import fr.xephi.authme.security.crypts.description.Usage;
-import fr.xephi.authme.security.crypts.description.Recommendation;
-import fr.xephi.authme.security.crypts.description.SaltType;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.util.StringUtils;
-
 import java.io.UnsupportedEncodingException;
 import java.security.SecureRandom;

+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.security.crypts.description.HasSalt;
+import fr.xephi.authme.security.crypts.description.Recommendation;
+import fr.xephi.authme.security.crypts.description.SaltType;
+import fr.xephi.authme.security.crypts.description.Usage;
+import fr.xephi.authme.settings.Settings;
+import fr.xephi.authme.util.StringUtils;
+
 /**
+ * <p>
 * BCrypt implements OpenBSD-style Blowfish password hashing using the scheme
 * described in "A Future-Adaptable Password Scheme" by Niels Provos and David
 * Mazieres.
- * <p/>
+ * </p><p>
 * This password hashing system tries to thwart off-line password cracking using
 * a computationally-intensive hashing algorithm, based on Bruce Schneier's
 * Blowfish cipher. The work factor of the algorithm is parameterised, so it can
 * be increased as computers get faster.
- * <p/>
+ * </p><p>
 * Usage is really simple. To hash a password for the first time, call the
 * hashpw method with a random salt, like this:
- * <p/>
+ * </p><p>
 * <code>
- * String pw_hash = BCrypt.hashpw(plain_password, BCrypt.gensalt()); <br />
+ * String pw_hash = BCrypt.hashpw(plain_password, BCrypt.gensalt()); <br>
 * </code>
- * <p/>
+ * </p><p>
 * To check whether a plaintext password matches one that has been hashed
 * previously, use the checkpw method:
- * <p/>
+ * </p><p>
 * <code>
- * if (BCrypt.checkpw(candidate_password, stored_hash))<br />
- * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It matches");<br />
- * else<br />
- * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It does not match");<br />
+ * if (BCrypt.checkpw(candidate_password, stored_hash))<br>
+ * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It matches");<br>
+ * else<br>
+ * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It does not match");<br>
 * </code>
- * <p/>
+ * </p><p>
 * The gensalt() method takes an optional parameter (log_rounds) that determines
 * the computational complexity of the hashing:
- * <p/>
+ * </p><p>
 * <code>
- * String strong_salt = BCrypt.gensalt(10)<br />
- * String stronger_salt = BCrypt.gensalt(12)<br />
+ * String strong_salt = BCrypt.gensalt(10)<br>
+ * String stronger_salt = BCrypt.gensalt(12)<br>
 * </code>
- * <p/>
+ * </p><p>
 * The amount of work increases exponentially (2**log_rounds), so each increment
 * is twice as much work. The default log_rounds is 10, and the valid range is 4
 * to 31.
- *
+ * </p>
 * @author Damien Miller
 * @version 0.2
 */
@@ -241,8 +241,9 @@ public class WHIRLPOOL extends UnsaltedMethod {
     *
     * @param source     plaintext data to hash.
     * @param sourceBits how many bits of plaintext to process.
-     *                   <p/>
-     *                   This method maintains the invariant: bufferBits < 512
+     *                   <p>
+     *                   This method maintains the invariant: bufferBits &lt; 512
+     *                   </p>
     */
    public void NESSIEadd(byte[] source, long sourceBits) {
        /*
@@ -322,10 +323,12 @@ public class WHIRLPOOL extends UnsaltedMethod {
    }

    /**
+     * <p>
     * Get the hash value from the hashing state.
-     * <p/>
-     * This method uses the invariant: bufferBits < 512
-     *
+     * </p>
+     * <p>
+     * This method uses the invariant: bufferBits &lt; 512
+     * </p>
     * @param digest byte[]
     */
    public void NESSIEfinalize(byte[] digest) {
@@ -367,7 +370,7 @@ public class WHIRLPOOL extends UnsaltedMethod {
     * Delivers string input data to the hashing algorithm.
     *
     * @param source plaintext data to hash (ASCII text string).
-     *               This method maintains the invariant: bufferBits < 512
+     *               This method maintains the invariant: bufferBits &lt; 512
     */
    public void NESSIEadd(String source) {
        if (source.length() > 0) {
@@ -13,10 +13,14 @@ import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
 public @interface HasSalt {

-    /** The type of the salt. */
+    /** The type of the salt.
+     * @return salttype The SaltType
+     */
    SaltType value();

-    /** For text salts, the length of the salt. */
+    /** For text salts, the length of the salt.
+     * @return int Integer
+     */
    int length() default 0;

 }
@@ -12,7 +12,9 @@ import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
 public @interface Recommendation {

-    /** The recommendation for using the hash algorithm. */
+    /** The recommendation for using the hash algorithm.
+     * @return Usage The Usage
+     */
    Usage value();

 }
@@ -1,15 +1,16 @@
 package fr.xephi.authme.security.pbkdf2;

-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.security.NoSuchProviderException;

+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
+
 /**
- * Default PRF implementation based on standard javax.crypt.Mac mechanisms.
 * <p>
- * <hr />
+ * Default PRF implementation based on standard javax.crypt.Mac mechanisms.
+ * </p>
 * <p>
 * A free Java implementation of Password Based Key Derivation Function 2 as
 * defined by RFC 2898. Copyright (c) 2007 Matthias G&auml;rtner
@@ -75,7 +75,7 @@ public interface PBKDF2 {
    /**
     * Allow setting of configured parameters.
     *
-     * @param parameters
+     * @param parameters PBKDF2Parameters
     */
    void setParameters(PBKDF2Parameters parameters);

@@ -8,20 +8,17 @@ import java.security.SecureRandom;
 /**
 * <p>
 * Request for Comments: 2898 PKCS #5: Password-Based Cryptography Specification
- * <p>
+ * </p><p>
 * Version 2.0
- * <p>
+ * </p>
 * <p>
 * PBKDF2 (P, S, c, dkLen)
- * <p>
- * <p>
+ * </p>
 * Options:
 * <ul>
 * <li>PRF underlying pseudorandom function (hLen denotes the length in octets
 * of the pseudorandom function output). PRF is pluggable.</li>
 * </ul>
- * <p>
- * <p>
 * Input:
 * <ul>
 * <li>P password, an octet string</li>
@@ -30,15 +27,11 @@ import java.security.SecureRandom;
 * <li>dkLen intended length in octets of the derived key, a positive integer,
 * at most (2^32 - 1) * hLen</li>
 * </ul>
- * <p>
- * <p>
 * Output:
 * <ul>
 * <li>DK derived key, a dkLen-octet string</li>
 * </ul>
 * <p>
- * <hr />
- * <p>
 * A free Java implementation of Password Based Key Derivation Function 2 as
 * defined by RFC 2898. Copyright (c) 2007 Matthias G&auml;rtner
 * </p>
@@ -115,13 +108,14 @@ public class PBKDF2Engine implements PBKDF2 {
     * ISO-8559-1 encoding. Output result as
     * &quot;Salt:iteration-count:PBKDF2&quot; with binary data in hexadecimal
     * encoding.
-     * <p/>
+     * <p>
     * Example: Password &quot;password&quot; (without the quotes) leads to
     * 48290A0B96C426C3:1000:973899B1D4AFEB3ED371060D0797E0EE0142BD04
-     *
+     * </p>
     * @param args Supply the password as argument.
     *
-     * @throws IOException * @throws NoSuchAlgorithmException * @throws NoSuchAlgorithmException
+     * @throws IOException an ioexception occured
+     * @throws NoSuchAlgorithmException a NoSuchAlgorithmException occured
     */
    public static void main(String[] args)
        throws IOException, NoSuchAlgorithmException {
@@ -266,8 +260,8 @@ public class PBKDF2Engine implements PBKDF2 {
    /**
     * Integer division with ceiling function.
     *
-     * @param a
-     * @param b
+     * @param a Integer
+     * @param b Integer
     *
     * @return ceil(a/b) * @see <a href="http://tools.ietf.org/html/rfc2898">RFC 2898 5.2 Step
     * 2.</a>
@@ -288,7 +282,7 @@ public class PBKDF2Engine implements PBKDF2 {
     * @param prf        Pseudo Random Function
     * @param S          Salt as array of bytes
     * @param c          Iteration count
-     * @param blockIndex
+     * @param blockIndex Integer
     *
     * @see <a href="http://tools.ietf.org/html/rfc2898">RFC 2898 5.2 Step
     * 3.</a>
@@ -314,8 +308,8 @@ public class PBKDF2Engine implements PBKDF2 {
     * Block-Xor. Xor source bytes into destination byte buffer. Destination
     * buffer must be same length or less than source buffer.
     *
-     * @param dest
-     * @param src
+     * @param dest byte array
+     * @param src byte array
     */
    protected void xor(byte[] dest, byte[] src) {
        for (int i = 0; i < dest.length; i++) {
@@ -326,9 +320,9 @@ public class PBKDF2Engine implements PBKDF2 {
    /**
     * Four-octet encoding of the integer i, most significant octet first.
     *
-     * @param dest
-     * @param offset
-     * @param i
+     * @param dest byte array
+     * @param offset Integer
+     * @param i Integer
     *
     * @see <a href="http://tools.ietf.org/html/rfc2898">RFC 2898 5.2 Step
     * 3.</a>
@@ -5,8 +5,6 @@ package fr.xephi.authme.security.pbkdf2;
 * Parameter data holder for PBKDF2 configuration.
 * </p>
 * <p>
- * <hr />
- * <p>
 * A free Java implementation of Password Based Key Derivation Function 2 as
 * defined by RFC 2898. Copyright (c) 2007 Matthias G&auml;rtner
 * </p>