Advanced Search

Java Signature And Verification Utils

/ Published in: Java
Save to your folder(s)

Expand | Embed | Plain Text

Copy this code and paste it in your HTML 
  1. import java.io.BufferedInputStream;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.security.InvalidKeyException;
  8. import java.security.Key;
  9. import java.security.KeyPair;
  10. import java.security.KeyStore;
  11. import java.security.KeyStoreException;
  12. import java.security.NoSuchAlgorithmException;
  13. import java.security.PrivateKey;
  14. import java.security.PublicKey;
  15. import java.security.Signature;
  16. import java.security.SignatureException;
  17. import java.security.UnrecoverableKeyException;
  18. import java.security.cert.CertificateException;
  19. import java.security.cert.CertificateFactory;
  20.  
  21. import org.apache.commons.io.output.ByteArrayOutputStream;
  22. import org.bouncycastle.util.encoders.Base64Encoder;
  23.  
  24. public class Utils {
  25.  
  26. 	private static final String STRING_ENCODING = "UTF-8";
  27.  
  28. 	public static KeyStore loadKeyStore(File file, String storePassword)
  29. 			throws IOException, KeyStoreException, NoSuchAlgorithmException,
  30. 			CertificateException {
  31. 		return loadKeyStore(KeyStore.getDefaultType(), file, storePassword);
  32. 	}
  33.  
  34. 	public static KeyStore loadKeyStore(String storeType, File file,
  35. 			String storePassword) throws IOException, KeyStoreException,
  36. 			NoSuchAlgorithmException, CertificateException {
  37. 		FileInputStream is = new FileInputStream(file);
  38. 		try {
  39. 			KeyStore keystore = KeyStore.getInstance(storeType);
  40. 			keystore.load(is,
  41. 					storePassword == null ? null : storePassword.toCharArray());
  42.  
  43. 			return keystore;
  44. 		} finally {
  45. 			is.close();
  46. 		}
  47. 	}
  48.  
  49. 	public static KeyPair getKeyPair(KeyStore keyStore, String alias,
  50. 			String keyPassword) throws UnrecoverableKeyException,
  51. 			KeyStoreException, NoSuchAlgorithmException,
  52. 			PrivateKeyNotFoundException {
  53. 		Key key = getKey(keyStore, alias, keyPassword);
  54. 		if (key instanceof PrivateKey) {
  55. 			return new KeyPair(getPublicKey(keyStore, alias), (PrivateKey) key);
  56. 		} else {
  57. 			throw new PrivateKeyNotFoundException("The given key " + alias
  58. 					+ " is not a private key.");
  59. 		}
  60. 	}
  61.  
  62. 	public static PublicKey getPublicKey(KeyStore keyStore, String alias)
  63. 			throws KeyStoreException {
  64. 		return keyStore.getCertificate(alias).getPublicKey();
  65. 	}
  66.  
  67. 	public static Key getKey(KeyStore keyStore, String alias, String keyPassword)
  68. 			throws KeyStoreException, NoSuchAlgorithmException,
  69. 			UnrecoverableKeyException {
  70. 		return keyStore.getKey(alias,
  71. 				keyPassword == null ? null : keyPassword.toCharArray());
  72. 	}
  73.  
  74. 	public static PublicKey loadPublicKeyFromCertificate(File certificateFile)
  75. 			throws FileNotFoundException, CertificateException, IOException {
  76. 		return loadPublicKeyFromCertificate(certificateFile, "X.509");
  77. 	}
  78.  
  79. 	public static PublicKey loadPublicKeyFromCertificate(File certificateFile,
  80. 			String certificateType) throws FileNotFoundException,
  81. 			CertificateException, IOException {
  82. 		PublicKey publicKey = null;
  83. 		FileInputStream fis = new FileInputStream(certificateFile);
  84. 		try {
  85.  
  86. 			CertificateFactory cf = CertificateFactory
  87. 					.getInstance(certificateType);
  88. 			java.security.cert.Certificate cert = cf.generateCertificate(fis);
  89. 			publicKey = cert.getPublicKey();
  90. 		} finally {
  91. 			fis.close();
  92. 		}
  93. 		return publicKey;
  94. 	}
  95.  
  96. 	public static boolean verify(File certificateFile, File signatureFile,
  97. 			File dataFile, String signAlgorithm) throws FileNotFoundException,
  98. 			IOException, CertificateException, NoSuchAlgorithmException,
  99. 			InvalidKeyException, SignatureException {
  100. 		byte[] sigToVerify = null;
  101. 		FileInputStream sigfis = new FileInputStream(signatureFile);
  102. 		try {
  103. 			sigToVerify = new byte[sigfis.available()];
  104. 			sigfis.read(sigToVerify);
  105. 		} finally {
  106. 			sigfis.close();
  107. 		}
  108.  
  109. 		return verify(dataFile, sigToVerify, certificateFile, signAlgorithm);
  110. 	}
  111.  
  112. 	public static boolean verify(File dataFile, byte[] sigToVerify,
  113. 			File certificateFile, String signAlgorithm)
  114. 			throws FileNotFoundException, IOException, CertificateException,
  115. 			NoSuchAlgorithmException, InvalidKeyException, SignatureException {
  116. 		FileInputStream keyfis = new FileInputStream(certificateFile);
  117. 		try {
  118. 			byte[] encKey = new byte[keyfis.available()];
  119. 			keyfis.read(encKey);
  120. 		} finally {
  121. 			keyfis.close();
  122. 		}
  123.  
  124. 		PublicKey pubKey = loadPublicKeyFromCertificate(certificateFile);
  125.  
  126. 		Signature sig = Signature.getInstance(signAlgorithm);
  127. 		sig.initVerify(pubKey);
  128.  
  129. 		FileInputStream datafis = new FileInputStream(dataFile);
  130.  
  131. 		try {
  132. 			BufferedInputStream bufin = new BufferedInputStream(datafis);
  133. 			try {
  134. 				byte[] buffer = new byte[1024];
  135. 				int len;
  136. 				while (bufin.available() != 0) {
  137. 					len = bufin.read(buffer);
  138. 					sig.update(buffer, 0, len);
  139. 				}
  140. 			} finally {
  141. 				if (bufin != null) {
  142. 					bufin.close();
  143. 				}
  144. 			}
  145. 		} finally {
  146. 			if (datafis != null) {
  147. 				datafis.close();
  148. 			}
  149.  
  150. 		}
  151.  
  152. 		return sig.verify(sigToVerify);
  153. 	}
  154.  
  155. 	public static boolean verifyUsingBase64Decode(File certificateFile,
  156. 			File signatureFile, File dataFile, String signAlgorithm)
  157. 			throws FileNotFoundException, IOException, CertificateException,
  158. 			NoSuchAlgorithmException, InvalidKeyException, SignatureException {
  159. 		byte[] sigToVerify = null;
  160. 		FileInputStream sigfis = new FileInputStream(signatureFile);
  161. 		try {
  162. 			sigToVerify = new byte[sigfis.available()];
  163. 			sigfis.read(sigToVerify);
  164. 		} finally {
  165. 			sigfis.close();
  166. 		}
  167.  
  168. 		ByteArrayOutputStream signStream = new ByteArrayOutputStream();
  169. 		new Base64Encoder().decode(sigToVerify, 0, sigToVerify.length,
  170. 				signStream);
  171. 		return verify(dataFile, signStream.toByteArray(), certificateFile,
  172. 				signAlgorithm);
  173. 	}
  174.  
  175. 	public static boolean verify(File certificateFile, File signatureFile,
  176. 			String data, String signAlgorithm) throws FileNotFoundException,
  177. 			IOException, CertificateException, NoSuchAlgorithmException,
  178. 			InvalidKeyException, SignatureException {
  179. 		byte[] sigToVerify = null;
  180. 		FileInputStream sigfis = new FileInputStream(signatureFile);
  181. 		try {
  182. 			sigToVerify = new byte[sigfis.available()];
  183. 			sigfis.read(sigToVerify);
  184. 		} finally {
  185. 			sigfis.close();
  186. 		}
  187.  
  188. 		return verify(data, sigToVerify, certificateFile, signAlgorithm);
  189. 	}
  190.  
  191. 	public static boolean verify(String dataFile, byte[] sigToVerify,
  192. 			File certificateFile, String signAlgorithm)
  193. 			throws FileNotFoundException, IOException, CertificateException,
  194. 			NoSuchAlgorithmException, InvalidKeyException, SignatureException {
  195. 		FileInputStream keyfis = new FileInputStream(certificateFile);
  196. 		try {
  197. 			byte[] encKey = new byte[keyfis.available()];
  198. 			keyfis.read(encKey);
  199. 		} finally {
  200. 			keyfis.close();
  201. 		}
  202.  
  203. 		PublicKey pubKey = loadPublicKeyFromCertificate(certificateFile);
  204.  
  205. 		Signature sig = Signature.getInstance(signAlgorithm);
  206. 		sig.initVerify(pubKey);
  207.  
  208. 		sig.update(dataFile.getBytes(STRING_ENCODING));
  209.  
  210. 		return sig.verify(sigToVerify);
  211. 	}
  212.  
  213. 	public static boolean verifyUsingBase64Decode(File certificateFile,
  214. 			File signatureFile, String data, String signAlgorithm)
  215. 			throws FileNotFoundException, IOException, CertificateException,
  216. 			NoSuchAlgorithmException, InvalidKeyException, SignatureException {
  217. 		byte[] sigToVerify = null;
  218. 		FileInputStream sigfis = new FileInputStream(signatureFile);
  219. 		try {
  220. 			sigToVerify = new byte[sigfis.available()];
  221. 			sigfis.read(sigToVerify);
  222. 		} finally {
  223. 			sigfis.close();
  224. 		}
  225.  
  226. 		ByteArrayOutputStream signStream = new ByteArrayOutputStream();
  227. 		new Base64Encoder().decode(sigToVerify, 0, sigToVerify.length,
  228. 				signStream);
  229. 		return verify(data, signStream.toByteArray(), certificateFile,
  230. 				signAlgorithm);
  231. 	}
  232.  
  233. 	protected static void writeToFileUsingBase64Encode(byte[] realSig, File f2)
  234. 			throws FileNotFoundException, IOException {
  235. 		FileOutputStream sigfos2 = new FileOutputStream(f2);
  236. 		new Base64Encoder().encode(realSig, 0, realSig.length, sigfos2);
  237. 		sigfos2.close();
  238. 	}
  239.  
  240. 	protected static void writeToFile(File file, byte[] realSig)
  241. 			throws FileNotFoundException, IOException {
  242. 		FileOutputStream sigfos = new FileOutputStream(file);
  243. 		try {
  244. 			sigfos.write(realSig);
  245. 		} finally {
  246. 			sigfos.close();
  247. 		}
  248. 	}
  249.  
  250. 	public static byte[] sign(File dataToSign, File keyStoreFile,
  251. 			String storePassword, String alias, String keyPassword,
  252. 			String signAlgorithm) throws IOException, KeyStoreException,
  253. 			NoSuchAlgorithmException, CertificateException,
  254. 			UnrecoverableKeyException, PrivateKeyNotFoundException,
  255. 			InvalidKeyException, FileNotFoundException, SignatureException {
  256. 		Signature dsa = null;
  257.  
  258. 		KeyStore keyStore = loadKeyStore(keyStoreFile, storePassword);
  259. 		KeyPair pair = getKeyPair(keyStore, alias, keyPassword);
  260. 		PrivateKey priv = pair.getPrivate();
  261.  
  262. 		dsa = Signature.getInstance(signAlgorithm);
  263.  
  264. 		dsa.initSign(priv);
  265.  
  266. 		FileInputStream fis = new FileInputStream(dataToSign);
  267. 		try {
  268. 			BufferedInputStream bufin = new BufferedInputStream(fis);
  269. 			try {
  270. 				byte[] buffer = new byte[1024];
  271. 				int len;
  272. 				while (bufin.available() != 0) {
  273. 					len = bufin.read(buffer);
  274. 					dsa.update(buffer, 0, len);
  275. 				}
  276. 			} finally {
  277. 				if (bufin != null) {
  278. 					bufin.close();
  279. 				}
  280. 			}
  281. 		} finally {
  282. 			if (fis != null) {
  283. 				fis.close();
  284. 			}
  285. 		}
  286.  
  287. 		return dsa.sign();
  288. 	}
  289.  
  290. 	public static byte[] sign(String dataToSign, File keyStoreFile,
  291. 			String storePassword, String alias, String keyPassword,
  292. 			String signAlgorithm) throws IOException, KeyStoreException,
  293. 			NoSuchAlgorithmException, CertificateException,
  294. 			UnrecoverableKeyException, PrivateKeyNotFoundException,
  295. 			InvalidKeyException, FileNotFoundException, SignatureException {
  296. 		Signature dsa = null;
  297.  
  298. 		KeyStore keyStore = loadKeyStore(keyStoreFile, storePassword);
  299. 		KeyPair pair = getKeyPair(keyStore, alias, keyPassword);
  300. 		PrivateKey priv = pair.getPrivate();
  301. 		dsa = Signature.getInstance(signAlgorithm);
  302. 		dsa.initSign(priv);
  303. 		dsa.update(dataToSign.getBytes(STRING_ENCODING));
  304. 		return dsa.sign();
  305. 	}
  306.  
  307. }

Report this snippet


Comments

RSS Icon Subscribe to comments

You need to login to post a comment.