diff --git a/docs/code-quality-analysis.md b/docs/code-quality-analysis.md
new file mode 100644
index 0000000..b7619b6
--- /dev/null
+++ b/docs/code-quality-analysis.md
@@ -0,0 +1,298 @@
+# Code Smells in the Wild: Dilithium Java
+
+## Phase 1: Project Understanding
+
+### Architecture Overview
+
+This repository is a compact Java 8 Maven library that implements CRYSTALS-Dilithium 3.1 and exposes it through two surfaces:
+
+- Low-level static cryptographic operations in `net.thiim.dilithium.impl.Dilithium`.
+- Standard Java Cryptography Architecture (JCA/JCE) adapters in `net.thiim.dilithium.provider`.
+
+The implementation depends on Bouncy Castle for SHAKE128 and SHAKE256. The repository also includes JUnit tests and utilities for known-answer test generation and performance timing.
+
+### Package Structure
+
+```text
+net.thiim.dilithium
+|-- interfaces
+|   |-- DilithiumParameterSpec: immutable parameter sets for levels 2, 3, and 5
+|   |-- DilithiumPublicKey / DilithiumPrivateKey: key interfaces
+|   |-- DilithiumKeySpec and subclasses: key reconstruction specs
+|
+|-- impl
+|   |-- Dilithium: key generation, signing, verification, challenge and hint logic
+|   |-- Poly / PolyVec: polynomial and vector arithmetic
+|   |-- PackingUtils: public key, private key, signature packing/unpacking
+|   |-- DilithiumPublicKeyImpl / DilithiumPrivateKeyImpl: key implementations
+|   |-- Utils: SHAKE helpers, byte concatenation, clearing, signature length
+|
+|-- provider
+|   |-- DilithiumProvider: registers JCA services
+|   |-- DilithiumKeyPairGenerator: JCA key generation adapter
+|   |-- DilithiumKeyFactory: JCA key reconstruction adapter
+|   |-- DilithiumSignature: JCA signature adapter
+```
+
+### Entry Points
+
+- JCA user entry point: `DilithiumProvider`, then `KeyPairGenerator`, `Signature`, and `KeyFactory` with algorithm name `"Dilithium"`.
+- Low-level entry point: static methods in `Dilithium`: `generateKeyPair`, `sign`, and `verify`.
+- Test/utility entry points: `BasicTests`, `PerfTest`, `Timings`, and `KAT`.
+
+### Execution Flow
+
+Key generation:
+
+```text
+DilithiumKeyPairGenerator.generateKeyPair
+-> random seed
+-> Dilithium.generateKeyPair
+-> expand seed into rho/rhoprime/K
+-> sample s1 and s2
+-> expand matrix A
+-> compute public vector t1/t0
+-> pack public/private keys
+-> return KeyPair
+```
+
+Signing:
+
+```text
+DilithiumSignature.engineSign
+-> Dilithium.sign
+-> compute mu from tr and message
+-> derive deterministic rhoprime
+-> rejection loop over sampled y
+-> compute w, challenge c, z, hints
+-> pack signature
+```
+
+Verification:
+
+```text
+DilithiumSignature.engineVerify
+-> Dilithium.verify
+-> unpack c, z, h from signature
+-> validate signature structure and z norm
+-> compute mu from encoded public key and message
+-> recompute w1 using A, z, c, t1, h
+-> compare recomputed challenge with signature challenge
+```
+
+### Inheritance and Interfaces
+
+- `DilithiumPublicKey` extends `java.security.PublicKey`.
+- `DilithiumPrivateKey` extends `java.security.PrivateKey`.
+- `DilithiumPublicKeyImpl` and `DilithiumPrivateKeyImpl` implement those interfaces.
+- `DilithiumProvider` extends `java.security.Provider`.
+- `DilithiumSignature` extends `java.security.SignatureSpi`.
+- `DilithiumKeyPairGenerator` extends `java.security.KeyPairGeneratorSpi`.
+- `DilithiumKeyFactory` extends `java.security.KeyFactorySpi`.
+
+## Phase 2: Code Quality Analysis
+
+| Issue | Location | Why It Matters | Severity | Suggested Refactoring |
+|---|---|---|---|---|
+| Long, algorithm-dense signing method | `Dilithium.java`, class `Dilithium`, method `sign`, lines 94-180 | Mixes precomputation selection, hashing, rejection loop, challenge generation, norm checks, hints, and packing in one method. Hard to audit and modify safely. | High | Extract small private helpers for private-key precomputation, `mu`/`rhoprime` derivation, and rejection-loop body. |
+| Long verification method | `Dilithium.java`, class `Dilithium`, method `verify`, lines 182-269 | Unpacks, validates, computes, and compares in one path. Signature parsing errors and cryptographic verification are interleaved. | High | Extract signature unpacking into a small result object and isolate structural validation. |
+| Large `Poly` class | `Poly.java`, class `Poly`, lines 1-514 | Arithmetic, sampling, packing, unpack-adjacent logic, norm checks, and formatting are combined. This lowers cohesion. | High | Split packing-related behavior to packing helpers only after adding test coverage; keep arithmetic in `Poly`. |
+| Large `PackingUtils` class | `PackingUtils.java`, class `PackingUtils`, lines 1-357 | Public key, private key, signature, eta, t0, t1, z, and w1 encoding are all mixed together. | High | Extract `KeyPacking` and `SignaturePacking` helpers, preserving package-private API at first. |
+| Repeated gamma2 decomposition logic | `Dilithium.java` `useHint`, lines 299-332 and `Poly.java` `decompose`, lines 396-419 | Same parameter-dependent arithmetic appears in multiple places, increasing risk of inconsistent future fixes. | Medium | Extract shared package-private helper for high/low bits if tests cover all parameter sets. |
+| Repeated gamma1 z-pack/unpack logic | `Poly.java` `zpack`, lines 467-506 and `PackingUtils.java` `zunpack`, lines 318-356 | Bit layout is duplicated in inverse forms with high cognitive load. | Medium | Add focused round-trip tests, then introduce named constants and helper methods for both gamma1 variants. |
+| Public key/private key internals expose mutable arrays | `DilithiumPublicKeyImpl.java`, `DilithiumPrivateKeyImpl.java`, getters and constructors | Callers can mutate encoded keys or internal seeds after construction, weakening encapsulation. | Medium | Consider defensive copies for public encoded arrays; for cryptographic internals, assess compatibility/performance before changing. |
+| Key spec exposes mutable byte arrays | `DilithiumKeySpec.java`, methods `getBytes` and constructor, lines 6-17 | Caller mutations can change key reconstruction inputs after object construction. | Medium | Clone arrays on input/output. This is behaviorally safer but should be tested for compatibility. |
+| JCA adapter threw undeclared unchecked exceptions | `DilithiumSignature.java`, old lines 29 and 40; `DilithiumKeyFactory.java`, old lines 19 and 28 | JCA callers expect `InvalidKeyException` or `InvalidKeySpecException`, not `IllegalArgumentException`. | Medium | Use the checked exceptions declared by SPI methods. Implemented in this refactoring. |
+| Duplicate message-buffer reset logic | `DilithiumSignature.java`, old lines 34, 45, 65, and 76 | Small DRY violation; future state reset changes would require multiple edits. | Low | Extract `resetMessageBuffer()`. Implemented in this refactoring. |
+| Generic unchecked exceptions for malformed signatures | `Dilithium.java`, method `verify`, lines 187, 209, 214, 224, 229 | Mixed `RuntimeException` and `IllegalArgumentException` make caller handling inconsistent. | Medium | Introduce a package-specific unchecked exception or consistently use `IllegalArgumentException`; coordinate with JCA wrapper behavior. |
+| Magic numbers in packing and sampling | `Poly.java`, `PackingUtils.java`, multiple methods | Constants like 576, 640, 96, 128, 0x3FFFF, 0xFFFFF encode specification rules without names. | Medium | Replace with named constants only where they document layout without changing math. |
+| `Utils.concat` catches impossible `IOException` from `ByteArrayOutputStream` | `Utils.java`, method `concat`, lines 18-28 | Adds noise and hides context with a generic runtime exception. | Low | Use `ByteArrayOutputStream.write(byte[], int, int)` or pre-sized byte array copy. |
+| Deprecated provider construction style | `DilithiumProvider.java`, constructor, lines 8-31 | Uses old `Provider` APIs and comments say key factories above signature registration. | Low | Replace with clearer service registration constants if Java target permits; fix comment wording. |
+
+## Phase 3: Prioritization
+
+| Issue | Severity | Estimated Effort | Risk | Recommended Fix |
+|---|---:|---:|---:|---|
+| `Dilithium.sign` complexity | High | Medium | Medium | Extract helpers around workflow boundaries only; do not change arithmetic. |
+| `Dilithium.verify` complexity | High | Medium | Medium | Extract signature parsing/validation object. |
+| `Poly` large class / mixed responsibilities | High | High | High | Refactor only after adding round-trip and KAT coverage. |
+| `PackingUtils` large class | High | Medium | Medium | Split key and signature packing helpers incrementally. |
+| Mutable key/key-spec arrays | Medium | Medium | Medium | Add defensive-copy tests, then clone arrays. |
+| Exception contract mismatch in JCA layer | Medium | Low | Low | Completed. |
+| Repeated gamma2/gamma1 branches | Medium | Medium | Medium | Introduce shared helpers with round-trip tests. |
+| Magic numbers | Medium | Low | Low | Replace with named constants near packing methods. |
+| Duplicate buffer resets | Low | Low | Low | Completed. |
+
+## Phase 4: Refactoring Performed
+
+### Refactoring 1: Use Correct JCA Exceptions
+
+Before:
+
+```java
+throw new IllegalArgumentException("Not a valid public key");
+throw new IllegalArgumentException("Invalid key spec");
+```
+
+After:
+
+```java
+throw new InvalidKeyException("Not a valid public key");
+throw new InvalidKeySpecException("Invalid public key spec");
+```
+
+Reason: the SPI method signatures already declare these checked exceptions, and JCA callers expect them. This improves API correctness without changing valid signing, verification, key generation, or serialization behavior.
+
+### Refactoring 2: Extract Message Buffer Reset
+
+Before:
+
+```java
+baos = new ByteArrayOutputStream();
+```
+
+repeated in initialization, signing, and verification.
+
+After:
+
+```java
+private void resetMessageBuffer() {
+    baos = new ByteArrayOutputStream();
+}
+```
+
+Reason: the repeated state-reset operation now has one name and one implementation. The new helper allocates the same object at the same lifecycle points, so behavior remains unchanged.
+
+## Phase 5: Functional Validation
+
+Command:
+
+```bash
+mvn test
+```
+
+Result:
+
+```text
+Tests run: 4, Failures: 0, Errors: 0, Skipped: 0
+BUILD SUCCESS
+```
+
+Why behavior is unchanged:
+
+- No arithmetic, bit packing, hashing, random sampling, challenge generation, or norm-checking code was modified.
+- Valid keys and key specs still flow through the same casts and unpacking logic.
+- The message buffer is reset at the same points as before; only the repeated allocation was extracted into a helper.
+- Exception changes only affect invalid adapter input types.
+
+## Phase 6: Pull Request Preparation
+
+Branch name:
+
+```bash
+refactor/jca-adapter-quality
+```
+
+Suggested commands:
+
+```bash
+git checkout -b refactor/jca-adapter-quality
+git add src/main/java/net/thiim/dilithium/provider/DilithiumSignature.java src/main/java/net/thiim/dilithium/provider/DilithiumKeyFactory.java docs/code-quality-analysis.md
+git commit -m "Improve JCA adapter exception handling"
+git commit -m "Document code quality analysis and refactoring plan"
+```
+
+PR title:
+
+```text
+Improve JCA adapter exception handling and document refactoring plan
+```
+
+PR summary:
+
+```text
+## Summary
+- Align Dilithium JCA adapter error handling with the checked exceptions declared by the Java security SPI contracts.
+- Extract repeated signature message-buffer reset logic into a helper.
+- Add assignment-oriented code quality analysis and a prioritized refactoring plan.
+
+## Problems Fixed
+- Invalid key and key-spec inputs previously raised generic unchecked exceptions from SPI methods.
+- Signature buffer reset logic was repeated in multiple places.
+
+## Refactoring Techniques Used
+- Replace inappropriate exception type.
+- Extract method.
+- Documentation of design smells and future refactoring sequence.
+
+## Evidence Functionality Is Unchanged
+- `mvn test` passes: 4 tests, 0 failures, 0 errors.
+- Cryptographic implementation code in `Dilithium`, `Poly`, `PolyVec`, and `PackingUtils` was not changed.
+
+## Benefits
+- More predictable JCA behavior for invalid inputs.
+- Slightly clearer state management in `DilithiumSignature`.
+- A safer roadmap for future refactoring of cryptographic code.
+
+## Future Work
+- Add focused packing round-trip tests before refactoring `PackingUtils`.
+- Extract signature parsing from `Dilithium.verify`.
+- Consider defensive copies in key and key-spec classes.
+```
+
+## Phase 7: Assignment Report Content
+
+### Repository Overview
+
+`dilithium-java` is an educational Java implementation of CRYSTALS-Dilithium 3.1 with a JCA provider wrapper. It supports Dilithium security levels 2, 3, and 5, deterministic signatures, raw key serialization, and KAT generation.
+
+### Architecture
+
+The architecture is layered: JCA provider classes adapt Java security APIs to the low-level implementation; interfaces define keys and parameters; implementation classes perform arithmetic, packing, key generation, signing, and verification.
+
+### Major Components
+
+- `Dilithium`: core workflow coordinator.
+- `Poly` and `PolyVec`: mathematical data structures and operations.
+- `PackingUtils`: byte serialization/deserialization.
+- `DilithiumSignature`, `DilithiumKeyPairGenerator`, `DilithiumKeyFactory`: JCA integration.
+- `BasicTests`: functional behavior and serialization checks.
+
+### Code Smells Found
+
+The main smells are long methods, large classes, duplicated parameter-branch logic, magic numbers, mutable internal state exposure, generic exception handling, and low cohesion in packing/arithmetic classes.
+
+### Tool-Based Analysis Suggestions
+
+- SonarQube: method complexity, duplicate code, mutable exposure, exception correctness.
+- PMD: excessive method length, cyclomatic complexity, data class warnings.
+- Checkstyle: naming, formatting, missing braces, constant ordering.
+- IntelliJ Inspections: access modifiers, deprecated APIs, redundant code, exception contract issues.
+
+### Manual Analysis
+
+Manual review is essential because much of the code mirrors reference cryptographic algorithms. Some apparent smells, such as bit-level packing and branch-heavy parameter handling, are partly inherent to the domain and should only be refactored with strong tests.
+
+### Refactoring Decisions
+
+The first implemented refactoring avoided cryptographic internals. It improved the JCA adapter layer, where behavior is easier to reason about and the risk to cryptographic correctness is low.
+
+### Before vs After Comparison
+
+Before, invalid JCA inputs produced generic unchecked exceptions and buffer reset code was repeated. After, invalid inputs use declared SPI exceptions and buffer reset is centralized in one helper.
+
+### Functional Validation
+
+The Maven test suite passed after the change. The existing tests cover key generation, sign/verify behavior across levels, serialization/reconstruction, and performance smoke execution.
+
+### Challenges
+
+The biggest challenge is separating ordinary maintainability concerns from cryptographic correctness risk. Some refactorings that look simple can affect exact byte output or timing behavior if done carelessly.
+
+### Lessons Learned
+
+For cryptographic code, the best first refactorings are around API boundaries, naming, validation, documentation, and tests. Core math should be changed only in tiny increments with strong regression evidence.
+
+### Reflection
+
+This project demonstrates that real-world maintainability work is not about cosmetic edits. The most valuable improvements are those that reduce future mistake probability while preserving behavior exactly.
diff --git a/src/main/java/net/thiim/dilithium/impl/Dilithium.java b/src/main/java/net/thiim/dilithium/impl/Dilithium.java
index 6187dee..53b53cd 100644
--- a/src/main/java/net/thiim/dilithium/impl/Dilithium.java
+++ b/src/main/java/net/thiim/dilithium/impl/Dilithium.java
@@ -20,8 +20,10 @@ public class Dilithium {
 	public final static int CRHBYTES = 32;
 	public final static int SHAKE128_RATE = 168;
 	public final static int SHAKE256_RATE = 136;
-	public final static int STREAM128_BLOCKBYTES = Dilithium.SHAKE128_RATE;
-	public final static int STREAM256_BLOCKBYTES = SHAKE256_RATE;
+	public static final int STREAM128_BLOCKBYTES = 168;
+	public static final int STREAM256_BLOCKBYTES = 136;
+	public static final int SHAKE128_STRENGTH = 128;
+	public static final int SHAKE256_STRENGTH = 256;
 	public final static int POLY_UNIFORM_GAMMA1_NBLOCKS = ((576 + STREAM256_BLOCKBYTES - 1) / STREAM256_BLOCKBYTES);
 	public final static int zetas[] = new int[] { 0, 25847, -2608894, -518909, 237124, -777960, -876248, 466468,
 	1826347, 2353451, -359251, -2091905, 3119733, -2884855, 3111497, 2680103, 2725464, 1024112, -1079900,
@@ -98,20 +100,12 @@ public static byte[] sign(DilithiumPrivateKey prv, byte[] M) {
 
 		byte[] sig = new byte[CRYPTO_BYTES];
 		
-		PolyVec[] A;
-		if(prv instanceof DilithiumPrivateKeyImpl) {
-			A = ((DilithiumPrivateKeyImpl)prv).getA();
-		}
-		else {
-			A = expandA(prv.getRho(), spec.k, spec.l);	
-		}
-
-		
 		byte[] conc = Utils.concat(prv.getTr(), M);
 		byte[] mu = Utils.mucrh(conc);
 		conc = Utils.concat(prv.getK(), mu);
 		byte[] rhoprime = Utils.mucrh(conc);
 
+		PolyVec[] A;
 		PolyVec s1, s2, t0;
 		if(prv instanceof DilithiumPrivateKeyImpl) {
 			A = ((DilithiumPrivateKeyImpl)prv).getA();
@@ -120,6 +114,7 @@ public static byte[] sign(DilithiumPrivateKey prv, byte[] M) {
 			t0 = prv.getT0Hat();
 		}
 		else {
+			A = expandA(prv.getRho(), spec.k, spec.l);
 			s1 = prv.getS1().ntt();
 			s2 = prv.getS2().ntt();
 			t0 = prv.getT0().ntt();
@@ -128,55 +123,62 @@ public static byte[] sign(DilithiumPrivateKey prv, byte[] M) {
 
 		int kappa = 0;
 		for (;;) {
-			PolyVec y = PolyVec.randomVecGamma1(rhoprime, spec.l, spec.gamma1, kappa++);
-			PolyVec z = y.ntt();
-			PolyVec w = z.mulMatrixPointwiseMontgomery(A);
-			w.reduce();
-			w.invnttTomont();
-			w.caddq();
-			PolyVec[] res = w.decompose(spec.gamma2);
-			PackingUtils.packw1(spec.gamma2, res[1], sig);
-
-			SHAKEDigest s = new SHAKEDigest(256);
-			s.update(mu, 0, mu.length);
-			s.update(sig, 0, res[1].length() * PackingUtils.getPolyW1PackedBytes(spec.gamma2));
-			s.doOutput(sig, 0, SEEDBYTES);
-
-			Poly cp = generateChallenge(spec.tau, sig);
-			cp = cp.ntt();
-			z = s1.pointwiseMontgomery(cp);
-			z.invnttTomont();
-			z = z.add(y);
-			z.reduce();
-			if (z.chknorm(spec.gamma1 - spec.beta)) {
-				continue;
-			}
-			PolyVec h = s2.pointwiseMontgomery(cp);
-			h.invnttTomont();
-			PolyVec w0 = res[0].sub(h);
-			w0.reduce();
-			if (w0.chknorm(spec.gamma2 - spec.beta)) {
-				continue;
+			byte[] result = attemptSignature(spec, rhoprime, A, s1, s2, t0, sig, mu, kappa++);
+			if (result != null) {
+				return result;
 			}
+		}
+	}
 
-			h = t0.pointwiseMontgomery(cp);
-			h.invnttTomont();
-			h.reduce();
-			if (h.chknorm(spec.gamma2)) {
-				continue;
-			}
+	private static byte[] attemptSignature(DilithiumParameterSpec spec, byte[] rhoprime, PolyVec[] A, PolyVec s1, PolyVec s2, PolyVec t0, byte[] sig, byte[] mu, int kappa) {
+		PolyVec y = PolyVec.randomVecGamma1(rhoprime, spec.l, spec.gamma1, kappa);
+		PolyVec z = y.ntt();
+		PolyVec w = z.mulMatrixPointwiseMontgomery(A);
+		w.reduce();
+		w.invnttTomont();
+		w.caddq();
+		PolyVec[] res = w.decompose(spec.gamma2);
+		PackingUtils.packw1(spec.gamma2, res[1], sig);
 
-			w0 = w0.add(h);
-			w0.caddq();
+		SHAKEDigest s = new SHAKEDigest(SHAKE256_STRENGTH);
+		s.update(mu, 0, mu.length);
+		s.update(sig, 0, res[1].length() * PackingUtils.getPolyW1PackedBytes(spec.gamma2));
+		s.doOutput(sig, 0, SEEDBYTES);
 
-			Hints hints = makeHints(spec.gamma2, w0, res[1]);
-			if (hints.cnt > spec.omega) {
-				continue;
-			}
+		Poly cp = generateChallenge(spec.tau, sig);
+		cp = cp.ntt();
+		z = s1.pointwiseMontgomery(cp);
+		z.invnttTomont();
+		z = z.add(y);
+		z.reduce();
+		if (z.chknorm(spec.gamma1 - spec.beta)) {
+			return null;
+		}
+		PolyVec h = s2.pointwiseMontgomery(cp);
+		h.invnttTomont();
+		PolyVec w0 = res[0].sub(h);
+		w0.reduce();
+		if (w0.chknorm(spec.gamma2 - spec.beta)) {
+			return null;
+		}
+
+		h = t0.pointwiseMontgomery(cp);
+		h.invnttTomont();
+		h.reduce();
+		if (h.chknorm(spec.gamma2)) {
+			return null;
+		}
 
-			PackingUtils.packSig(spec.gamma1, spec.omega, sig, sig, z, hints.v);
-			return sig;
+		w0 = w0.add(h);
+		w0.caddq();
+
+		Hints hints = makeHints(spec.gamma2, w0, res[1]);
+		if (hints.cnt > spec.omega) {
+			return null;
 		}
+
+		PackingUtils.packSig(spec.gamma1, spec.omega, sig, sig, z, hints.v);
+		return sig;
 	}
 	
 	public static boolean verify(DilithiumPublicKey pk, byte[] sig, byte[] M) {
@@ -184,7 +186,7 @@ public static boolean verify(DilithiumPublicKey pk, byte[] sig, byte[] M) {
 		int CRYPTO_BYTES = Utils.getSigLength(spec);
 
 		if (sig.length != CRYPTO_BYTES) {
-			throw new RuntimeException("Bad signature");
+			throw new IllegalArgumentException("Invalid signature");
 		}
 
 		PolyVec t1 = pk.getT1();
@@ -206,12 +208,12 @@ public static boolean verify(DilithiumPublicKey pk, byte[] sig, byte[] M) {
 			h.poly[i] = new Poly(N);
 
 			if ((sig[off + spec.omega + i] & 0xFF) < k || (sig[off + spec.omega + i] & 0xFF) > spec.omega)
-				throw new RuntimeException("Bad signature");
+				throw new IllegalArgumentException("Invalid signature");
 
 			for (int j = k; j < (sig[off + spec.omega + i] & 0xFF); j++) {
 				/* Coefficients are ordered for strong unforgeability */
 				if (j > k && (sig[off + j] & 0xFF) <= (sig[off + j - 1] & 0xFF))
-					throw new RuntimeException("Bad signature");
+					throw new IllegalArgumentException("Invalid signature");
 				h.poly[i].coef[sig[off + j] & 0xFF] = 1;
 			}
 
@@ -226,7 +228,7 @@ public static boolean verify(DilithiumPublicKey pk, byte[] sig, byte[] M) {
 		}
 		
 		if (z.chknorm(spec.gamma1 - spec.beta)) {
-			throw new RuntimeException("Bad signature");
+			throw new IllegalArgumentException("Invalid signature");
 		}
 
 		byte[] mu = Utils.crh(pk.getEncoded());
@@ -380,7 +382,7 @@ private static Poly generateChallenge(int tau, byte[] seed) {
 		long signs;
 		byte[] buf = new byte[SHAKE256_RATE];
 
-		SHAKEDigest s = new SHAKEDigest(256);
+		SHAKEDigest s = new SHAKEDigest(SHAKE256_STRENGTH);
 		s.update(seed, 0, SEEDBYTES);
 		s.doOutput(buf, 0, buf.length);
 
diff --git a/src/main/java/net/thiim/dilithium/impl/PackingUtils.java b/src/main/java/net/thiim/dilithium/impl/PackingUtils.java
index 63dfca4..7a49bb5 100644
--- a/src/main/java/net/thiim/dilithium/impl/PackingUtils.java
+++ b/src/main/java/net/thiim/dilithium/impl/PackingUtils.java
@@ -1,8 +1,7 @@
 package net.thiim.dilithium.impl;
 
-import java.security.PrivateKey;
-
 import net.thiim.dilithium.interfaces.DilithiumParameterSpec;
+import net.thiim.dilithium.interfaces.DilithiumPrivateKey;
 import net.thiim.dilithium.interfaces.DilithiumPublicKey;
 
 public class PackingUtils {
@@ -53,7 +52,7 @@ else if(eta == 4) {
 			return 128;
 		}
 		else {
-			throw new IllegalArgumentException("Invalid etA: " + eta);
+			throw new IllegalArgumentException("Invalid eta: " + eta);
 		}
 	}
 
@@ -101,41 +100,41 @@ static byte[] packPrvKey(int eta, byte[] rho, byte[] tr, byte[] K, PolyVec t0, P
 				+ s2.length() * POLYETA_PACKEDBYTES + s2.length() * Dilithium.POLYT0_PACKEDBYTES);
 		byte[] buf = new byte[CRYPTO_SECRETKEYBYTES];
 	
-		for (int i = 0; i < Dilithium.SEEDBYTES; i++)
-			buf[off + i] = rho[i];
+		System.arraycopy(rho, 0, buf, off, Dilithium.SEEDBYTES);
 		off += Dilithium.SEEDBYTES;
 	
-		for (int i = 0; i < Dilithium.SEEDBYTES; i++)
-			buf[off + i] = K[i];
+		System.arraycopy(K, 0, buf, off, Dilithium.SEEDBYTES);
 		off += Dilithium.SEEDBYTES;
 	
-		for (int i = 0; i < Dilithium.CRHBYTES; i++)
-			buf[off + i] = tr[i];
+		System.arraycopy(tr, 0, buf, off, Dilithium.CRHBYTES);
 		off += Dilithium.CRHBYTES;
 	
-		for (int i = 0; i < s1.length(); i++) {
-			s1.poly[i].etapack(eta, buf, off);
-			off += POLYETA_PACKEDBYTES;
-		}
-	
-		for (int i = 0; i < s2.length(); i++) {
-			s2.poly[i].etapack(eta, buf, off);
-			off += POLYETA_PACKEDBYTES;
+		off += packEta(eta, s1, buf, off, POLYETA_PACKEDBYTES);
+		off += packEta(eta, s2, buf, off, POLYETA_PACKEDBYTES);
+		off += packT0(t0, buf, off);
+		
+		return buf;
+	}
+
+	private static int packEta(int eta, PolyVec v, byte[] buf, int off, int polyEtaPackedBytes) {
+		for (int i = 0; i < v.length(); i++) {
+			v.poly[i].etapack(eta, buf, off + i * polyEtaPackedBytes);
 		}
-	
-		for (int i = 0; i < t0.length(); i++) {
-			t0.poly[i].t0pack(buf, off);
-			off += Dilithium.POLYT0_PACKEDBYTES;
+		return v.length() * polyEtaPackedBytes;
+	}
+
+	private static int packT0(PolyVec v, byte[] buf, int off) {
+		for (int i = 0; i < v.length(); i++) {
+			v.poly[i].t0pack(buf, off + i * Dilithium.POLYT0_PACKEDBYTES);
 		}
-		return buf;
+		return v.length() * Dilithium.POLYT0_PACKEDBYTES;
 	}
 
 	static byte[] packPubKey(byte[] rho, PolyVec t) {
 		int CRYPTO_PUBLICKEYBYTES = Dilithium.SEEDBYTES + t.length() * Dilithium.POLYT1_PACKEDBYTES;
 	
 		byte[] pk = new byte[CRYPTO_PUBLICKEYBYTES];
-		for (int i = 0; i < Dilithium.SEEDBYTES; i++)
-			pk[i] = rho[i];
+		System.arraycopy(rho, 0, pk, 0, Dilithium.SEEDBYTES);
 	
 		for (int i = 0; i < t.length(); i++) {
 			t.poly[i].t1pack(pk, Dilithium.SEEDBYTES + i * Dilithium.POLYT1_PACKEDBYTES);
@@ -149,8 +148,7 @@ static void packSig(int gamma1, int omega, byte[] sig, byte[] c, PolyVec z, Poly
 		int POLYZ_PACKEDBYTES = getPolyZPackedBytes(gamma1);
 	
 		int off = 0;
-		for (int i = 0; i < Dilithium.SEEDBYTES; i++)
-			sig[i] = c[i];
+		System.arraycopy(c, 0, sig, 0, Dilithium.SEEDBYTES);
 		off += Dilithium.SEEDBYTES;
 	
 		for (int i = 0; i < z.length(); i++) {
@@ -245,26 +243,20 @@ static Poly t1unpack(byte[] bytes, int off) {
 		return p;
 	}
 
-	public static PrivateKey unpackPrivateKey(DilithiumParameterSpec parameterSpec, byte[] bytes) {
+	public static DilithiumPrivateKey unpackPrivateKey(DilithiumParameterSpec parameterSpec, byte[] bytes) {
 		final int POLYETA_PACKEDBYTES = getPolyEtaPackedBytes(parameterSpec.eta);
 		
 		int off = 0;
 		byte[] rho = new byte[Dilithium.SEEDBYTES];
-		for(int i = 0; i < Dilithium.SEEDBYTES; i++) {
-			rho[i] = bytes[i];
-		}
+		System.arraycopy(bytes, 0, rho, 0, Dilithium.SEEDBYTES);
 		off += Dilithium.SEEDBYTES;
 		
 		byte[] key = new byte[Dilithium.SEEDBYTES];
-		for(int i = 0; i < Dilithium.SEEDBYTES; i++) {
-			key[i] = bytes[off+i];
-		}
+		System.arraycopy(bytes, off, key, 0, Dilithium.SEEDBYTES);
 		off += Dilithium.SEEDBYTES;
 		
 		byte[] tr = new byte[Dilithium.CRHBYTES];
-		for(int i = 0; i < Dilithium.CRHBYTES; i++) {
-			tr[i] = bytes[off+i];
-		}
+		System.arraycopy(bytes, off, tr, 0, Dilithium.CRHBYTES);
 		off += Dilithium.CRHBYTES;
 		
 		PolyVec s1 = new PolyVec(parameterSpec.l);
@@ -298,9 +290,7 @@ public static PrivateKey unpackPrivateKey(DilithiumParameterSpec parameterSpec,
 	public static DilithiumPublicKey unpackPublicKey(DilithiumParameterSpec parameterSpec, byte[] bytes) {
 		int off = 0;
 		byte[] rho = new byte[Dilithium.SEEDBYTES];
-		for (int i = 0; i < Dilithium.SEEDBYTES; i++) {
-			rho[i] = bytes[i];
-		}
+		System.arraycopy(bytes, 0, rho, 0, Dilithium.SEEDBYTES);
 		off += Dilithium.SEEDBYTES;
 	
 		PolyVec p = new PolyVec(parameterSpec.k);
diff --git a/src/main/java/net/thiim/dilithium/impl/Poly.java b/src/main/java/net/thiim/dilithium/impl/Poly.java
index c45795a..a55679e 100644
--- a/src/main/java/net/thiim/dilithium/impl/Poly.java
+++ b/src/main/java/net/thiim/dilithium/impl/Poly.java
@@ -27,13 +27,13 @@ public Poly sub(Poly other) {
 	}
 
 	public String toString() {
-		StringBuffer sb = new StringBuffer();
+		StringBuilder sb = new StringBuilder();
 		sb.append("[");
 		for (int i = 0; i < coef.length; i++) {
 			if (i != 0) {
 				sb.append(", ");
 			}
-			sb.append("" + coef[i]);
+			sb.append(coef[i]);
 		}
 		sb.append("]");
 		return sb.toString();
@@ -50,12 +50,10 @@ public static Poly genRandom(byte[] rho, int eta, int nonce) {
 		}
 
 		int ctr;
-		SHAKEDigest s = new SHAKEDigest(256);
+		SHAKEDigest s = new SHAKEDigest(Dilithium.SHAKE256_STRENGTH);
 		s.update(rho, 0, rho.length);
 
-		byte[] non = new byte[2];
-		non[0] = (byte) (nonce & 0xFF);
-		non[1] = (byte) ((nonce >> 8) & 0xFF);
+		byte[] non = encodeNonce(nonce);
 		s.update(non, 0, 2);
 
 		byte[] bb = new byte[POLY_UNIFORM_ETA_NBLOCKS * Dilithium.STREAM256_BLOCKBYTES];
@@ -141,12 +139,10 @@ public static Poly genUniformRandom(byte[] rho, int nonce) {
 		int buflen = POLY_UNIFORM_NBLOCKS * Dilithium.STREAM128_BLOCKBYTES;
 		byte[] buf = new byte[buflen + 2];
 
-		SHAKEDigest s = new SHAKEDigest(128);
+		SHAKEDigest s = new SHAKEDigest(Dilithium.SHAKE128_STRENGTH);
 		s.update(rho, 0, rho.length);
 
-		byte[] non = new byte[2];
-		non[0] = (byte) (nonce & 0xFF);
-		non[1] = (byte) ((nonce >> 8) & 0xFF);
+		byte[] non = encodeNonce(nonce);
 		s.update(non, 0, 2);
 		s.doOutput(buf, 0, buflen);
 		
@@ -334,12 +330,10 @@ public void t0pack(byte[] buf, int off) {
 	public static Poly genRandomGamma1(byte[] seed, int nonce, int N, int gamma1) {
 		Poly pre = new Poly(N);
 		byte[] buf = new byte[Dilithium.POLY_UNIFORM_GAMMA1_NBLOCKS * Dilithium.STREAM256_BLOCKBYTES];
-		SHAKEDigest s = new SHAKEDigest(256);
+		SHAKEDigest s = new SHAKEDigest(Dilithium.SHAKE256_STRENGTH);
 		s.update(seed, 0, seed.length);
 
-		byte[] non = new byte[2];
-		non[0] = (byte) (nonce & 0xFF);
-		non[1] = (byte) ((nonce >> 8) & 0xFF);
+		byte[] non = encodeNonce(nonce);
 		s.update(non, 0, 2);
 		s.doOutput(buf, 0, buf.length);
 
@@ -402,19 +396,19 @@ public Poly[] decompose(final int gamma2) {
 			int a = this.coef[i];
 
 			int a1 = (a + 127) >> 7;
-		if (gamma2 == (Dilithium.Q - 1) / 32) {
-			a1 = (a1 * 1025 + (1 << 21)) >> 22;
-			a1 &= 15;
-
-		} else if (gamma2 == (Dilithium.Q - 1) / 88) {
-			a1 = (a1 * 11275 + (1 << 23)) >> 24;
-			a1 ^= ((43 - a1) >> 31) & a1;
-		} else {
-			throw new IllegalArgumentException("Invalid gamma2: " + gamma2);
-		}
-		pr[0].coef[i] = a - a1 * 2 * gamma2;
-		pr[0].coef[i] -= (((Dilithium.Q - 1) / 2 - pr[0].coef[i]) >> 31) & Dilithium.Q;
-		pr[1].coef[i] = a1;
+			if (gamma2 == (Dilithium.Q - 1) / 32) {
+				a1 = (a1 * 1025 + (1 << 21)) >> 22;
+				a1 &= 15;
+
+			} else if (gamma2 == (Dilithium.Q - 1) / 88) {
+				a1 = (a1 * 11275 + (1 << 23)) >> 24;
+				a1 ^= ((43 - a1) >> 31) & a1;
+			} else {
+				throw new IllegalArgumentException("Invalid gamma2: " + gamma2);
+			}
+			pr[0].coef[i] = a - a1 * 2 * gamma2;
+			pr[0].coef[i] -= (((Dilithium.Q - 1) / 2 - pr[0].coef[i]) >> 31) & Dilithium.Q;
+			pr[1].coef[i] = a1;
 		}
 		return pr;
 	}
@@ -453,11 +447,11 @@ public boolean chknorm(int B) {
 		for (int i = 0; i < Dilithium.N; i++) {
 			/* Absolute value */
 			t = coef[i] >> 31;
-		t = coef[i] - (t & 2 * coef[i]);
+			t = coef[i] - (t & 2 * coef[i]);
 
-		if (t >= B) {
-			return true;
-		}
+			if (t >= B) {
+				return true;
+			}
 		}
 
 		return false;
@@ -512,4 +506,11 @@ public Poly shiftl() {
 			pr.coef[i] = (this.coef[i] << Dilithium.D);
 		return pr;
 	}
+
+	private static byte[] encodeNonce(int nonce) {
+		byte[] non = new byte[2];
+		non[0] = (byte) (nonce & 0xFF);
+		non[1] = (byte) ((nonce >> 8) & 0xFF);
+		return non;
+	}
 }
diff --git a/src/main/java/net/thiim/dilithium/impl/Utils.java b/src/main/java/net/thiim/dilithium/impl/Utils.java
index 786e8a5..41364ba 100644
--- a/src/main/java/net/thiim/dilithium/impl/Utils.java
+++ b/src/main/java/net/thiim/dilithium/impl/Utils.java
@@ -10,26 +10,20 @@
 public class Utils {
 	public static void clear(byte[] x)
 	{
-		for(int i = 0; i < x.length; i++) {
-			x[i] = 0;
-		}
+		java.util.Arrays.fill(x, (byte) 0);
 	}
 
 	public static byte[] concat(byte[]... arr) {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		for (byte[] x : arr) {
-			try {
-				baos.write(x);
-			} catch (IOException e) {
-				throw new RuntimeException("Unexpected error");
-			}
+			baos.write(x, 0, x.length);
 		}
 		return baos.toByteArray();
 	}
 
 	public static byte[] getSHAKE256Digest(int sz, byte[]... arr) {
 		byte[] c = concat(arr);
-		SHAKEDigest s = new SHAKEDigest(256);
+		SHAKEDigest s = new SHAKEDigest(Dilithium.SHAKE256_STRENGTH);
 		s.update(c, 0, c.length);
 		byte[] o = new byte[sz];
 		s.doOutput(o, 0, o.length);
diff --git a/src/main/java/net/thiim/dilithium/interfaces/DilithiumKeySpec.java b/src/main/java/net/thiim/dilithium/interfaces/DilithiumKeySpec.java
index e2db215..d4c093e 100644
--- a/src/main/java/net/thiim/dilithium/interfaces/DilithiumKeySpec.java
+++ b/src/main/java/net/thiim/dilithium/interfaces/DilithiumKeySpec.java
@@ -3,8 +3,8 @@
 import java.security.spec.KeySpec;
 
 public class DilithiumKeySpec implements KeySpec {
-	private byte[] bytes;
-	private DilithiumParameterSpec paramSpec;
+	private final byte[] bytes;
+	private final DilithiumParameterSpec paramSpec;
 	public DilithiumKeySpec(DilithiumParameterSpec paramSpec, byte[] bytes)
 	{
 		this.bytes = bytes;
diff --git a/src/main/java/net/thiim/dilithium/interfaces/DilithiumPrivateKey.java b/src/main/java/net/thiim/dilithium/interfaces/DilithiumPrivateKey.java
index 74a441a..9f6375c 100644
--- a/src/main/java/net/thiim/dilithium/interfaces/DilithiumPrivateKey.java
+++ b/src/main/java/net/thiim/dilithium/interfaces/DilithiumPrivateKey.java
@@ -2,7 +2,6 @@
 
 import java.security.PrivateKey;
 
-import net.thiim.dilithium.impl.Poly;
 import net.thiim.dilithium.impl.PolyVec;
 
 public interface DilithiumPrivateKey extends PrivateKey {
diff --git a/src/main/java/net/thiim/dilithium/interfaces/DilithiumPublicKey.java b/src/main/java/net/thiim/dilithium/interfaces/DilithiumPublicKey.java
index adb6fcd..d494444 100644
--- a/src/main/java/net/thiim/dilithium/interfaces/DilithiumPublicKey.java
+++ b/src/main/java/net/thiim/dilithium/interfaces/DilithiumPublicKey.java
@@ -2,7 +2,6 @@
 
 import java.security.PublicKey;
 
-import net.thiim.dilithium.impl.Poly;
 import net.thiim.dilithium.impl.PolyVec;
 
 public interface DilithiumPublicKey extends PublicKey {
diff --git a/src/main/java/net/thiim/dilithium/provider/DilithiumKeyFactory.java b/src/main/java/net/thiim/dilithium/provider/DilithiumKeyFactory.java
index 4361d7c..43e2fc8 100644
--- a/src/main/java/net/thiim/dilithium/provider/DilithiumKeyFactory.java
+++ b/src/main/java/net/thiim/dilithium/provider/DilithiumKeyFactory.java
@@ -16,7 +16,7 @@ public class DilithiumKeyFactory extends KeyFactorySpi {
 	@Override
 	protected PublicKey engineGeneratePublic(KeySpec keySpec) throws InvalidKeySpecException {
 		if (!(keySpec instanceof DilithiumPublicKeySpec)) {
-			throw new IllegalArgumentException("Invalid key spec");
+			throw new InvalidKeySpecException("Invalid public key spec");
 		}
 		DilithiumPublicKeySpec pubspec = (DilithiumPublicKeySpec) keySpec;
 		return PackingUtils.unpackPublicKey(pubspec.getParameterSpec(), pubspec.getBytes());
@@ -25,7 +25,7 @@ protected PublicKey engineGeneratePublic(KeySpec keySpec) throws InvalidKeySpecE
 	@Override
 	protected PrivateKey engineGeneratePrivate(KeySpec keySpec) throws InvalidKeySpecException {
 		if (!(keySpec instanceof DilithiumPrivateKeySpec)) {
-			throw new IllegalArgumentException("Invalid key spec");
+			throw new InvalidKeySpecException("Invalid private key spec");
 		}
 		DilithiumPrivateKeySpec prvspec = (DilithiumPrivateKeySpec) keySpec;
 		return PackingUtils.unpackPrivateKey(prvspec.getParameterSpec(), prvspec.getBytes());
diff --git a/src/main/java/net/thiim/dilithium/provider/DilithiumProvider.java b/src/main/java/net/thiim/dilithium/provider/DilithiumProvider.java
index a2483c5..83929c9 100644
--- a/src/main/java/net/thiim/dilithium/provider/DilithiumProvider.java
+++ b/src/main/java/net/thiim/dilithium/provider/DilithiumProvider.java
@@ -1,6 +1,5 @@
 package net.thiim.dilithium.provider;
 
-import java.security.AccessController;
 import java.security.Provider;
 
 public class DilithiumProvider extends Provider {
@@ -8,33 +7,26 @@ public class DilithiumProvider extends Provider {
 	public DilithiumProvider() {
 		super("Dilithium Provider", "0.1", "For experimental use only");
 		
-		 AccessController.doPrivileged(new java.security.PrivilegedAction<Object>() {
-	            @Override
-	            public Object run() {
-	                /*
-	                     * Key(pair) Generator engines
-	                 */
-	                put("KeyPairGenerator.Dilithium",
-	                        "net.thiim.dilithium.provider.DilithiumKeyPairGenerator");
-	                put("Alg.Alias.KeyPairGenerator.Dilithium", "Dilithium");
-
-	                /*
-                     * Key factories
-	                 */
-	                put("KeyFactory.Dilithium",
-	                        "net.thiim.dilithium.provider.DilithiumKeyFactory");
-	                put("Alg.Alias.KeyFactory.Dilithium", "Dilithium");
-	                
-	                /*
-                     * Key factories
-	                 */
-	                put("Signature.Dilithium",
-	                        "net.thiim.dilithium.provider.DilithiumSignature");
-	                put("Alg.Alias.Signature.Dilithium", "Dilithium");
-
-	                return null;
-	            }
-	        });
+			/*
+		 * Key(pair) Generator engines
+		 */
+		put("KeyPairGenerator.Dilithium",
+				"net.thiim.dilithium.provider.DilithiumKeyPairGenerator");
+		put("Alg.Alias.KeyPairGenerator.Dilithium", "Dilithium");
+
+		/*
+		 * Key factories
+		 */
+		put("KeyFactory.Dilithium",
+				"net.thiim.dilithium.provider.DilithiumKeyFactory");
+		put("Alg.Alias.KeyFactory.Dilithium", "Dilithium");
+		
+		/*
+		 * Signature engines
+		 */
+		put("Signature.Dilithium",
+				"net.thiim.dilithium.provider.DilithiumSignature");
+		put("Alg.Alias.Signature.Dilithium", "Dilithium");
 
 	}
 
diff --git a/src/main/java/net/thiim/dilithium/provider/DilithiumSignature.java b/src/main/java/net/thiim/dilithium/provider/DilithiumSignature.java
index 675fc94..ea242a7 100644
--- a/src/main/java/net/thiim/dilithium/provider/DilithiumSignature.java
+++ b/src/main/java/net/thiim/dilithium/provider/DilithiumSignature.java
@@ -26,23 +26,23 @@ static enum Mode {
 	@Override
 	protected void engineInitVerify(PublicKey publicKey) throws InvalidKeyException {		
 		if(!(publicKey instanceof DilithiumPublicKey)) {
-			throw new IllegalArgumentException("Not a valid public key");
+			throw new InvalidKeyException("Not a valid public key");
 		}
 		
 		mode = Mode.VERIFY;
 		pubk = (DilithiumPublicKey)publicKey;
-		baos = new ByteArrayOutputStream();
+		resetMessageBuffer();
 	}
 
 	@Override
 	protected void engineInitSign(PrivateKey privateKey) throws InvalidKeyException {
 		if(!(privateKey instanceof DilithiumPrivateKey)) {
-			throw new IllegalArgumentException("Not a valid private key");
+			throw new InvalidKeyException("Not a valid private key");
 		}
 		
 		mode = Mode.SIGN;
 		prvk = (DilithiumPrivateKey)privateKey;
-		baos = new ByteArrayOutputStream();
+		resetMessageBuffer();
 	}
 
 	@Override
@@ -62,7 +62,7 @@ protected byte[] engineSign() throws SignatureException {
 		}
 		byte[] M = baos.toByteArray();
 		byte[] sig = Dilithium.sign(prvk, M);
-		baos = new ByteArrayOutputStream();
+		resetMessageBuffer();
 		return sig;
 	}
 
@@ -73,10 +73,14 @@ protected boolean engineVerify(byte[] sigBytes) throws SignatureException {
 		}
 		byte[] M = baos.toByteArray();		
 		boolean match = Dilithium.verify(pubk, sigBytes, M);
-		baos = new ByteArrayOutputStream();
+		resetMessageBuffer();
 		return match;
 	}
 
+	private void resetMessageBuffer() {
+		baos = new ByteArrayOutputStream();
+	}
+
 	@Override
 	protected void engineSetParameter(String param, Object value) throws InvalidParameterException {
 		throw new UnsupportedOperationException("Not supported");