// Personal Key Management System (PKMS) Simulation Program // by Byoungcheon Lee, Joongbu University // 2014. 9. 29 import java.util.Scanner; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.math.BigInteger; import java.nio.charset.Charset; import java.security.InvalidAlgorithmParameterException; import java.security.InvalidKeyException; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.KeyStore; import java.security.KeyStoreException; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.PrivateKey; import java.security.PublicKey; import java.security.Security; import java.security.Signature; import java.security.SignatureException; import java.security.UnrecoverableKeyException; import java.security.cert.CRLException; import java.security.cert.CertPath; import java.security.cert.CertPathValidator; import java.security.cert.CertPathValidatorException; import java.security.cert.CertStore; import java.security.cert.Certificate; import java.security.cert.CertificateEncodingException; import java.security.cert.CertificateException; import java.security.cert.CertificateExpiredException; import java.security.cert.CertificateFactory; import java.security.cert.CertificateNotYetValidException; import java.security.cert.CertificateParsingException; import java.security.cert.CollectionCertStoreParameters; import java.security.cert.PKIXCertPathValidatorResult; import java.security.cert.PKIXParameters; import java.security.cert.TrustAnchor; import java.security.cert.X509CRL; import java.security.cert.X509CRLEntry; import java.security.cert.X509Certificate; import java.security.cert.X509Extension; import java.security.spec.InvalidKeySpecException; import java.security.spec.X509EncodedKeySpec; import java.util.ArrayList; import java.util.Calendar; import java.util.Collections; import java.util.Date; import java.util.Formatter; import java.util.GregorianCalendar; import java.util.List; import java.util.Set; import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import javax.security.auth.x500.X500Principal; import org.bouncycastle.asn1.x509.BasicConstraints; import org.bouncycastle.asn1.x509.CRLReason; import org.bouncycastle.asn1.x509.KeyUsage; import org.bouncycastle.asn1.x509.X509Extensions; import org.bouncycastle.crypto.util.PublicKeyFactory; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.pqc.math.linearalgebra.ByteUtils; import org.bouncycastle.x509.X509V2CRLGenerator; import org.bouncycastle.x509.X509V3CertificateGenerator; import org.bouncycastle.x509.extension.AuthorityKeyIdentifierStructure; // import org.bouncycastle.x509.extension.SubjectKeyIdentifierStructure; @SuppressWarnings("deprecation") public class PKMS { // 파일 저장시 확장자 정리 // *.der : 인증서 // *.crl : 인증서취소목록 // *.key : 개인키를 키스토어에 저장 // *.pkey : 공개키를 바이트스트림으로 파일에 저장 // *.dsig : 기기인증서명을 바이트스트림으로 파일에 저장 // *.enc : 암호문을 바이트스트림으로 파일에 저장 // *.sig : 서명문을 바이트스트림으로 파일에 저장 enum CertType {ROOT,INTER,ENDENTITY}; // 인증서의 종류: 루트인증기관 인증서, 중간 인증기관 인증서, 개인인증서 // 함수 3개 선언 // 1. RSA 키생성 함수 - KeyPair를 리턴 public static KeyPair generateRSAKeyPair() throws NoSuchAlgorithmException { KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); kpg.initialize(1024); return kpg.genKeyPair(); } // 2. 인증서 생성 함수 public static X509Certificate generateCertificate( X500Principal subjectDN, // 주체 PublicKey pubKey, // 공개키 PrivateKey signatureKey, // 발급키 (발급자의 서명키) X509Certificate caCert, // 발급자 인증서 CertType type) // 인증서 종류 throws CertificateEncodingException,NoSuchProviderException,NoSuchAlgorithmException,SignatureException,InvalidKeyException,CertificateParsingException { X509V3CertificateGenerator certGen = new X509V3CertificateGenerator(); certGen.setSerialNumber(BigInteger.valueOf(System.currentTimeMillis())); // 인증서 일련번호를 현재시간정보로부터 설정 if(type==CertType.ROOT) // 루트인증서인 경우 발급자와 사용자가 똑같이 루트임 certGen.setIssuerDN(subjectDN); else // 일반 사용자 인증서인 경우 발급자는 함수에 입력된 값을 이용. caCert에 있는 subjectDN을 이용 certGen.setIssuerDN(caCert.getSubjectX500Principal()); certGen.setSubjectDN(subjectDN); // 사용자(주체)의 DN을 설정 GregorianCalendar currentDate = new GregorianCalendar(); // 발급시간은 현재 시간으로 GregorianCalendar expiredDate // 만료시간, 인증서의 유효기간은 2년으로 설정했음 = new GregorianCalendar(currentDate.get(Calendar.YEAR)+2,currentDate.get(Calendar.MONTH),currentDate.get(Calendar.DAY_OF_MONTH)); certGen.setNotBefore(currentDate.getTime()); // 유효기간 시작 설정 certGen.setNotAfter(expiredDate.getTime()); // 유효기간 만료 설정 certGen.setPublicKey(pubKey); // 공개키 설정 certGen.setSignatureAlgorithm("SHA1withRSAEncryption"); // 서명알고리즘 설정 if(type!=CertType.ROOT){ // 루트인증서인 경우의 확장영역 certGen.addExtension(X509Extensions.AuthorityKeyIdentifier, false, new AuthorityKeyIdentifierStructure(caCert)); // certGen.addExtension(X509Extensions.SubjectKeyIdentifier, false, // new SubjectKeyIdentifierStructure(pubKey)); } if(type!=CertType.ENDENTITY){ // 중간 인증기관인 경우의 확장영역. 키의 사용용도를 전자서명, 인증서 서명, CRL 서명의 용도로 사용할 수 있음 certGen.addExtension(X509Extensions.BasicConstraints, true, new BasicConstraints(0)); certGen.addExtension(X509Extensions.KeyUsage, true, new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyCertSign | KeyUsage.cRLSign)); } else // 일반 사용자인 경우의 확장영역. 키의 사용용도는 전자서명용, 키암호화용으로 사용 가능 certGen.addExtension(X509Extensions.KeyUsage, true, new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyEncipherment)); return certGen.generate(signatureKey,"BC"); // 인증서를 생성하여 결과로 리턴 } // 3. CRL 생성 함수. CRL은 인증기관이 생성하여 공표 public static X509CRL generateCRL( X509Certificate caCert, // CRL 발급자 인증서 PrivateKey signatureKey, // CRL 발급자 서명키 BigInteger serialNumber) // 폐지할 인증서 일련번호 throws CRLException,NoSuchProviderException,NoSuchAlgorithmException,SignatureException,InvalidKeyException{ X509V2CRLGenerator crlGen = new X509V2CRLGenerator(); // CRL을 위한 변수명 설정 crlGen.setIssuerDN(caCert.getSubjectX500Principal()); // CRL의 발급자는 인증기관 GregorianCalendar currentDate = new GregorianCalendar(); // 발급시간 GregorianCalendar nextDate // 다음 업데이트 시간 = new GregorianCalendar(currentDate.get(Calendar.YEAR)+1,(currentDate.get(Calendar.MONTH)+1)%12,currentDate.get(Calendar.DAY_OF_MONTH)); crlGen.setThisUpdate(currentDate.getTime()); crlGen.setNextUpdate(nextDate.getTime()); crlGen.setSignatureAlgorithm("SHA1withRSAEncryption"); // 서명알고리즘 설정 if(serialNumber!=null) // 폐지할 인증서의 일련번호를 엔트리에 추가 crlGen.addCRLEntry(serialNumber, currentDate.getTime(), CRLReason.superseded); return crlGen.generate(signatureKey,"BC"); // CRL을 생성하여 출력 } // 4. RSA 암호화 함수, 복호화 함수 public static byte[] rsaEncrypt(byte[] plain, PublicKey pubk) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException { Cipher c = Cipher.getInstance("RSA"); c.init(Cipher.ENCRYPT_MODE, pubk); byte[] cipher = c.doFinal(plain); return cipher; } public static byte[] rsaDecrypt(byte[] cipher, PrivateKey privk) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException { Cipher c = Cipher.getInstance("RSA"); c.init(Cipher.DECRYPT_MODE, privk); byte[] plain = c.doFinal(cipher); return plain; } // 5. RSA 서명 생성 함수, 서명 검증 함수 public static byte[] rsaSign(byte[] plain, PrivateKey privk) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, SignatureException { Signature sig = Signature.getInstance("MD5WithRSA"); sig.initSign(privk); sig.update(plain); byte[] signatureBytes = sig.sign(); return signatureBytes; } public static boolean rsaVerify(byte[] plain, byte[] sign, PublicKey pubk) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, SignatureException { Signature sig = Signature.getInstance("MD5WithRSA"); sig.initVerify(pubk); sig.update(plain); return sig.verify(sign); } // 6. RSA 서명/검증 함수 - 입력이 2개인 경우 , name: 기기명, key: 공개키 public static byte[] rsaSign(byte[] name, byte[] key, PrivateKey privk) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, SignatureException { Signature sig = Signature.getInstance("MD5WithRSA"); sig.initSign(privk); sig.update(name); sig.update(key); byte[] signatureBytes = sig.sign(); return signatureBytes; } public static boolean rsaVerify(byte[] m1, byte[] m2, byte[] sign, PublicKey pubk) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, SignatureException { Signature sig = Signature.getInstance("MD5WithRSA"); sig.initVerify(pubk); sig.update(m1); sig.update(m2); return sig.verify(sign); } public static String bytesToHex(byte[] bytes) { StringBuilder sb = new StringBuilder(bytes.length * 2); @SuppressWarnings("resource") Formatter formatter = new Formatter(sb); for (byte b : bytes) { formatter.format("%02x", b); } return sb.toString(); } // 메뉴 1. 인증기관 설정 함수 - 키생성, 인증서 생성, 저장 public static void InitializeCA() throws IOException { try{ // 1.1 키쌍생성 System.out.println(); System.out.println("1. 인증기관 설정 (인증기관 내부의 작업) "); System.out.println("1.1 키쌍 생성 "); KeyPair rootKeyPair = generateRSAKeyPair(); // 루트인증기관 키생성 및 인증서 발급 KeyPair interKeyPair = generateRSAKeyPair(); // 중간인증기관의 키생성 및 인증서 발급 // 1.2 인증서 생성 System.out.println("1.2 인증서 생성 "); X509Certificate rootCert = generateCertificate( new X500Principal("C=KR,CN=ROOT"), rootKeyPair.getPublic(), rootKeyPair.getPrivate(), null, CertType.ROOT); X509Certificate interCert = generateCertificate( new X500Principal("C=KR,CN=INTER"), interKeyPair.getPublic(), rootKeyPair.getPrivate(), rootCert, CertType.INTER); // 1.3 인증서취소목록(CRL) 생성 System.out.println("1.3 인증서취소목록(CRL) 생성 "); X509CRL rootCRL = generateCRL(rootCert,rootKeyPair.getPrivate(),null); X509CRL interCRL = generateCRL(interCert,interKeyPair.getPrivate(),null); // 1.4 인증서를 파일로 저장 System.out.println("1.4 인증서를 *.der 파일로 저장 "); FileOutputStream fos; fos = new FileOutputStream(new File("root.der")); fos.write(rootCert.getEncoded()); // 파일로 저장 fos.close(); fos = new FileOutputStream(new File("inter.der")); fos.write(interCert.getEncoded()); // 파일로 저장 fos.close(); // 1.5 개인키를 파일로 저장 System.out.println("1.5 개인키를 *.key 파일로 저장 "); char[] code = {'s','e','c','r','e','t','c','o','d','e'}; // 개인키 암호화를 위한 키 코드 설정. 편의상 고정하였음 // 이 소프트웨어를 여러 사용자가 사용하게 되는 경우 키 코드를 사용자 입력으로 받을 수 있도록 변경할 필요 // 중간인증기관의 개인키를 저장 KeyStore ks1 = KeyStore.getInstance(KeyStore.getDefaultType()); // 키스토어라는 형태로 저장하게 됨 ks1.load(null,null); X509Certificate[] chain1 = new X509Certificate[2]; // 키스토어에 저장시 인증체인 정보 필요. 루트로부터 사용자까지의 인증서 정보 chain1[0] = interCert; // 중간인증기관 인증서 (중간인증기관이 Alice에게 인증서를 발급) chain1[1] = rootCert; // 루트인증기관 인증서 (루트인증기관이 중간인증기관에게 인증서를 발급) ks1.setKeyEntry("InterPrivateKeyAlias",interKeyPair.getPrivate(),code,chain1); // 필요한 정보를 키스토어에 암호화하여 저장 fos = new FileOutputStream(new File("inter.key")); ks1.store(fos,code); // 키스토어의 내용을 code로 암호화하여 파일로 저장 fos.close(); // 루트인증기관의 개인키를 저장 KeyStore ks2 = KeyStore.getInstance(KeyStore.getDefaultType()); // 키스토어라는 형태로 저장하게 됨 ks2.load(null,null); X509Certificate[] chain2 = new X509Certificate[1]; // 키스토어에 저장시 인증체인 정보 필요. 루트로부터 사용자까지의 인증서 정보 chain2[0] = rootCert; // 루트인증기관 인증서 (루트인증기관이 중간인증기관에게 인증서를 발급) ks2.setKeyEntry("RootPrivateKeyAlias",rootKeyPair.getPrivate(),code,chain2); // 필요한 정보를 키스토어에 암호화하여 저장 fos = new FileOutputStream(new File("root.key")); ks2.store(fos,code); // 키스토어의 내용을 code로 암호화하여 파일로 저장 fos.close(); // 1.6 CRL을 파일로 저장 - 당장 쓸 일은 없음 System.out.println("1.6 CRL을 *.crl 파일로 저장 "); // 중간인증기관의 CRL fos = new FileOutputStream(new File("inter.crl")); fos.write(interCRL.getEncoded()); fos.close(); // 루트인증기관의 CRL fos = new FileOutputStream(new File("root.crl")); fos.write(rootCRL.getEncoded()); fos.close(); System.out.println(); } catch(NoSuchAlgorithmException nsae){ nsae.printStackTrace(); } catch(CertificateException ce){ ce.printStackTrace(); } catch(InvalidKeyException ike){ ike.printStackTrace(); } catch(SignatureException se){ se.printStackTrace(); } catch(NoSuchProviderException nspre){ nspre.printStackTrace(); } catch(KeyStoreException kse){ kse.printStackTrace(); } catch(CRLException nsae){ nsae.printStackTrace(); } } // 메뉴 2. 사용자에게 인증서 발급하는 함수 - 사용자가 인증서 발급 요청, 인증기관이 인증서 발급 public static void IssueCert(String userName) throws IOException, UnrecoverableKeyException, InvalidKeySpecException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { try{ byte[] m1, m2, s0, s1; System.out.println(); System.out.println("2. 사용자에게 인증서 발급 "); // 2.1 사용자 키쌍생성 (사용자) System.out.println("2.1 키쌍 생성 (사용자) "); KeyPair userKeyPair = generateRSAKeyPair(); // 사용자의 키쌍 생성 // 2.2 인증서 발급 요청 (사용자) // - 공개키를 바이트스트림으로 파일에 저장 (사용자) FileInputStream fis; FileOutputStream fos; fos = new FileOutputStream(new File(userName+".pkey")); fos.write(userKeyPair.getPublic().getEncoded()); fos.close(); // 개인키 소유 증명을 위해 서명을 작성 m1 = userName.getBytes(); // 사용자명 m2 = userKeyPair.getPublic().getEncoded(); // 기기의 공개키 s0 = rsaSign(m1, m2, userKeyPair.getPrivate()); // 두개의 메시지 m1, m2에 대해 개인키로 서명. fos = new FileOutputStream(new File(userName+".rsig")); // 인증서발급요청서명을 파일로 저장 fos.write(s0); fos.close(); // - 공개키, 인증서발급요청서명을 인증기관에게 전송 System.out.println("2.2 인증서 발급 요청 (사용자->인증기관) "); // 2.3 인증서 발급 (인증기관) // 중간인증기관의 인증서 읽어오기 CertificateFactory cf = CertificateFactory.getInstance("X.509"); fis = new FileInputStream(new File("inter.der")); X509Certificate interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); fis = new FileInputStream(new File("root.der")); X509Certificate rootCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 중간인증기관의 개인키 읽어오기 KeyStore ks; char[] code = {'s','e','c','r','e','t','c','o','d','e'}; // 개인키 암호화를 위한 키 코드 설정. 편의상 고정하였음 fis = new FileInputStream(new File("inter.key")); ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(fis,code); // 파일에서 읽어와서 키스토어에 로드 fis.close(); PrivateKey interPrivateKey = (PrivateKey)ks.getKey("InterPrivateKeyAlias",code); // 사용자의 공개키를 파일에서 읽어오기 fis = new FileInputStream(new File(userName+".pkey")); int size = fis.available(); byte[] s = new byte[size]; fis.read(s); fis.close(); X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(s); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey userPublicKey = keyFactory.generatePublic(pubKeySpec); // 인증서발급요청서명을 검증 fis = new FileInputStream(new File(userName+".rsig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); boolean result = rsaVerify(m1,m2,s1,userPublicKey); System.out.println(" - 인증서발급요청서명의 유효성 검증 (인증기관) : "+result); // 인증서 생성하기 X509Certificate userCert = generateCertificate( new X500Principal("C=KR,CN="+userName), userPublicKey, interPrivateKey, interCert, CertType.ENDENTITY); // 인증서를 파일로 저장하기 fos = new FileOutputStream(new File(userName+".der")); fos.write(userCert.getEncoded()); // 파일로 저장 fos.close(); // 인증서를 사용자에게 전송. 인증기관 인증서도 함께 전송 System.out.println("2.3 인증서를 사용자에게 전송 (인증기관->사용자) "); // 2.4 개인키를 파일로 저장 (사용자) System.out.println("2.4 개인키를 *.key 파일로 저장 (사용자) "); // 인증기관의 인증서 읽어오기 (사용자 개인키 저장에 인증서 체인이 필요) // System.out.println("\n* 1.2 인증서 읽어오기 "); fis = new FileInputStream(new File("inter.der")); interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); fis = new FileInputStream(new File("root.der")); rootCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 사용자의 개인키를 저장 KeyStore ks1 = KeyStore.getInstance(KeyStore.getDefaultType()); // 키스토어라는 형태로 저장하게 됨 ks1.load(null,null); X509Certificate[] chain1 = new X509Certificate[3]; // 키스토어에 저장시 인증체인 정보 필요. 루트로부터 사용자까지의 인증서 정보 chain1[0] = userCert; // 사용자 인증서 (중간인증기관이 Alice에게 인증서를 발급) chain1[1] = interCert; // 중간인증기관 인증서 (중간인증기관이 Alice에게 인증서를 발급) chain1[2] = rootCert; // 루트인증기관 인증서 (루트인증기관이 중간인증기관에게 인증서를 발급) ks1.setKeyEntry(userName+"PrivateKeyAlias",userKeyPair.getPrivate(),code,chain1); // 필요한 정보를 키스토어에 암호화하여 저장 fos = new FileOutputStream(new File(userName+".key")); ks1.store(fos,code); // 키스토어의 내용을 code로 암호화하여 파일로 저장 fos.close(); // 2.5 발급받은 인증서의 유효성 검증 (사용자) // 사용자 인증서 읽어오기 fis = new FileInputStream(new File(userName+".der")); X509Certificate userCert1 = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); fis = new FileInputStream(new File("inter.der")); interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 인증서의 유효성 검증 userCert1.checkValidity(); userCert1.verify(interCert.getPublicKey()); // 사용자 인증서의 유효성 검증 System.out.println("2.5 사용자 인증서의 유효성 검증 (사용자) "); System.out.println(); } catch(NoSuchAlgorithmException nsae){ nsae.printStackTrace(); } catch(CertificateException ce){ ce.printStackTrace(); } catch(InvalidKeyException ike){ ike.printStackTrace(); } catch(SignatureException se){ se.printStackTrace(); } catch(NoSuchProviderException nspre){ nspre.printStackTrace(); } catch(KeyStoreException kse){ kse.printStackTrace(); } } // 메뉴 3. 사용자의 기기를 등록하는 함수 - 기기인증서명 발급 public static void SetupDevice(String userName, String machineName) throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException, UnrecoverableKeyException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, SignatureException, InvalidKeySpecException { // PKMS (사용자 키관리서버), UD (사용자 기기) 간의 프로토콜 KeyPair machineKeyPair; // 사용자 기기에서 사용할 키쌍 FileInputStream fis; FileOutputStream fos; KeyStore ks; byte[] m1; // 사용자명+기기명 바이트스트림 byte[] m2; // 기기의 공개키 바이트스트림 byte[] s0; // 기기인증서명 byte[] s1=null; // 기기인증서명 (파일에서 읽어온 것) boolean result; // 기기인증서명 검증 결과 int size; // 파일에서 바이트스트림 읽어올때 크기 char[] code = {'s','e','c','r','e','t','c','o','d','e'}; // 개인키 암호화를 위한 키 코드 설정. 편의상 고정하였음 // 3.1 기기에서 사용할 키쌍 생성 (UD) machineKeyPair = generateRSAKeyPair(); // 새로운 키생성 System.out.println("3.1 기기 키쌍 생성 "); // 3.2 기기인증서명 발급 요청 (UD->PKMS) // 기기공개키를 파일로 저장 (UD) fos = new FileOutputStream(new File(userName+machineName+".pkey")); fos.write(machineKeyPair.getPublic().getEncoded()); fos.close(); System.out.println("3.2 기기인증서명 발급 요청 "); // 기기공개키를 PKMS에게 전송, 기기인증서명 발급요청 (UD) // 3.3 기기인증서명 발급 (PKMS->UD) // PKMS의 인증서 읽어오기 (PKMS) CertificateFactory cf = CertificateFactory.getInstance("X.509"); fis = new FileInputStream(new File(userName+".der")); X509Certificate userCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // PKMS의 개인키 읽어오기 (PKMS) fis = new FileInputStream(new File(userName+".key")); ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(fis,code); // 파일에서 읽어와서 키스토어에 로드 fis.close(); PrivateKey userPrivateKey = (PrivateKey)ks.getKey(userName+"PrivateKeyAlias",code); // 사용자 기기의 공개키를 파일에서 읽어오기 (PKMS) fis = new FileInputStream(new File(userName+machineName+".pkey")); size = fis.available(); byte[] s = new byte[size]; fis.read(s); fis.close(); X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(s); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey machinePublicKey = keyFactory.generatePublic(pubKeySpec); // 기기인증서명 생성 (PKMS) m1 = (userName+machineName).getBytes(); // 사용자명+기기명 함께 사용 m2 = machineKeyPair.getPublic().getEncoded(); // 기기의 공개키 s0 = rsaSign(m1, m2, userPrivateKey); // 두개의 메시지 m1, m2에 대해 인증키로 서명. fos = new FileOutputStream(new File(userName+machineName+".dsig")); // 기기인증서명을 파일로 저장 fos.write(s0); fos.close(); // 기기인증서명을 UD에게 전송 (PKMS->UD) // 사용자 인증서, 인증기관 인증서를 함께 전송 System.out.println("3.3 기기인증서명 발급 "); // 3.4 기기인증서명의 유효성 검증 (UD) // 기기인증서명 읽어오기 (UD) fis = new FileInputStream(new File(userName+machineName+".dsig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); m1 = (userName+machineName).getBytes(); m2 = machinePublicKey.getEncoded(); result = rsaVerify(m1,m2,s1,userCert.getPublicKey()); System.out.println("3.4 "+machineName+"의 기기인증서명 유효성 검증 : "+result); // 3.5 기기 개인키를 키스토어에 저장 // 인증기관의 인증서 읽어오기 fis = new FileInputStream(new File("inter.der")); X509Certificate interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); fis = new FileInputStream(new File("root.der")); X509Certificate rootCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 기기 개인키를 키스토어에 저장 X509Certificate[] chain = new X509Certificate[3]; // 키스토어에 저장시 인증체인 정보 필요. 루트로부터 사용자까지의 인증서 정보 chain[0] = userCert; // 사용자 인증서 chain[1] = interCert; // 중간인증기관 인증서 chain[2] = rootCert; // 루트인증기관 인증서 ks = KeyStore.getInstance(KeyStore.getDefaultType()); // 키스토어라는 형태로 저장하게 됨 ks.load(null,null); ks.setKeyEntry(userName+machineName+"PrivateKeyAlias",machineKeyPair.getPrivate(),code,chain); // 필요한 정보를 키스토어에 암호화하여 저장 fos = new FileOutputStream(new File(userName+machineName+".key")); ks.store(fos,code); // 키스토어의 내용을 code로 암호화하여 파일로 저장 fos.close(); System.out.println("3.5 기기 개인키를 키스토어에 저장 "); System.out.println(); } // 메뉴 4. 사용자의 기기 사이의 암호화/복호화 테스트 // 송신자 기기 (SUD), 수신자 기기 (RUD) 간의 프로토콜 // 송신자 기기는 수신자 기기의 공개키로 암호화하여 메시지 전송 public static void TestEncryption(String receiverName, String machineName) throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException, UnrecoverableKeyException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, SignatureException, NoSuchProviderException, InvalidKeySpecException { FileInputStream fis; FileOutputStream fos; KeyStore ks; byte[] m1; // 사용자명+기기명 바이트스트림 byte[] m2; // 기기의 공개키 바이트스트림 byte[] s0; // 기기인증서명 byte[] s1=null; // 기기인증서명 (파일에서 읽어온 것) boolean result; // 기기인증서명 검증 결과 int size; // 파일에서 바이트스트림 읽어올때 크기 char[] code = {'s','e','c','r','e','t','c','o','d','e'}; // 개인키 암호화를 위한 키 코드 설정. 편의상 고정하였음 // 4.1 수신자의 인증서 읽어와서 검증하기 (SUD) // 수신자 PKMS의 인증서 읽어오기 (SUD) CertificateFactory cf = CertificateFactory.getInstance("X.509"); fis = new FileInputStream(new File(receiverName+".der")); X509Certificate receiverCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 인증기관의 인증서 읽어오기 fis = new FileInputStream(new File("inter.der")); X509Certificate interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 인증서의 유효성 검증 receiverCert.checkValidity(); receiverCert.verify(interCert.getPublicKey()); // 사용자 인증서의 유효성 검증 System.out.println("4.1 수신자 인증서의 유효성 검증 : "); // 4.2 수신자 기기의 기기인증서명 검증 // 수신자의 기기인증서명 읽어오기 (SUD) fis = new FileInputStream(new File(receiverName+machineName+".dsig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); // 수신자 기기의 공개키를 파일에서 읽어오기 (SUD) fis = new FileInputStream(new File(receiverName+machineName+".pkey")); size = fis.available(); byte[] s = new byte[size]; fis.read(s); fis.close(); X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(s); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey machinePublicKey = keyFactory.generatePublic(pubKeySpec); // 수신자의 기기인증서명 검증 (SUD) m1 = (receiverName+machineName).getBytes(); m2 = machinePublicKey.getEncoded(); result = rsaVerify(m1,m2,s1,receiverCert.getPublicKey()); System.out.println("4.2 "+receiverName+machineName+"의 기기인증서명 유효성 검증 : "+result); // 4.3 암호문 전송하기 (SUD->RUD) String plaintext = "암호화 테스트"; Charset charset = Charset.forName("UTF-8"); byte[] ct; // 암호문 ct = rsaEncrypt(plaintext.getBytes(charset), machinePublicKey); // 암호문을 파일로 저장 fos = new FileOutputStream(new File(receiverName+machineName+".enc")); // 암호문을 파일로 저장 fos.write(ct); fos.close(); // 암호문을 수신자에게 전송 (SUD->RUD) System.out.println("4.3 암호문 전송 완료 "); System.out.println("메시지 : "+plaintext); System.out.println("암호문 : "+ByteUtils.toHexString(ct)); // 4.4 암호문 복호화하기 (RUD) // 암호문을 파일에서 읽어옴 fis = new FileInputStream(new File(receiverName+machineName+".enc")); size = fis.available(); byte[] ct1 = new byte[size]; fis.read(ct1); fis.close(); // 수신자 기기의 개인키 읽어오기. fis = new FileInputStream(new File(receiverName+machineName+".key")); ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(fis,code); // 파일에서 읽어와서 키스토어에 로드 fis.close(); PrivateKey machinePrivateKey = (PrivateKey)ks.getKey(receiverName+machineName+"PrivateKeyAlias",code); // 키스토어에서 개인키를 읽어올때 암호화 키 코드 필요 byte[] pt1 = rsaDecrypt(ct1,machinePrivateKey); String decryptedText = new String(pt1, charset); System.out.println("복호화 : "+decryptedText); System.out.println(); } // 메뉴 5. 사용자의 기기 사이의 서명/검증 테스트 // 송신자 기기 (SUD), 수신자 기기 (RUD) 간의 프로토콜 // 송신자 기기는 자신의 기기의 개인키로 서명하여 메시지 전송, 수신자 기기는 송신자 기기의 공개키로 서명 검증 public static void TestSignature(String senderName, String machineName) throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException, UnrecoverableKeyException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, SignatureException, NoSuchProviderException, InvalidKeySpecException { FileInputStream fis; FileOutputStream fos; KeyStore ks; byte[] m1; // 사용자명+기기명 바이트스트림 byte[] m2; // 기기의 공개키 바이트스트림 byte[] s0; // 기기인증서명 byte[] s1=null; // 기기인증서명 (파일에서 읽어온 것) boolean result; // 기기인증서명 검증 결과 int size; // 파일에서 바이트스트림 읽어올때 크기 char[] code = {'s','e','c','r','e','t','c','o','d','e'}; // 개인키 암호화를 위한 키 코드 설정. 편의상 고정하였음 // 5.1 송신자의 개인키 읽어오기 (SUD) fis = new FileInputStream(new File(senderName+machineName+".key")); ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(fis,code); // 파일에서 읽어와서 키스토어에 로드 fis.close(); PrivateKey machinePrivateKey = (PrivateKey)ks.getKey(senderName+machineName+"PrivateKeyAlias",code); // 키스토어에서 개인키를 읽어올때 암호화 키 코드 필요 System.out.println("5.1 송신자의 개인키 읽어오기 "); // 5.2 메시지 서명하기 (SUD) String message = "전자서명 테스트"; Charset charset = Charset.forName("UTF-8"); byte[] sigMessage = rsaSign(message.getBytes(charset), machinePrivateKey); // 메시지에 대해 기기개인키로 서명. // 서명값을 파일로 저장 fos = new FileOutputStream(new File(senderName+machineName+".sig")); // 서명문을 파일로 저장 fos.write(sigMessage); fos.close(); // 메시지와 서명문을 함께 수신자에게 전송 (SUD->RUD) System.out.println("5.2 전자서명값 전송 "); // 5.3 서명 검증하기 (RUD) // 송신자 PKMS의 인증서 읽어오기 (RUD) CertificateFactory cf = CertificateFactory.getInstance("X.509"); fis = new FileInputStream(new File(senderName+".der")); X509Certificate senderCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 인증기관의 인증서 읽어오기 fis = new FileInputStream(new File("inter.der")); X509Certificate interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 인증서의 유효성 검증 senderCert.checkValidity(); senderCert.verify(interCert.getPublicKey()); // 사용자 인증서의 유효성 검증 System.out.println(" - 송신자 인증서의 유효성 검증 : "); // 송신자의 기기인증서명 읽어오기 (RUD) fis = new FileInputStream(new File(senderName+machineName+".dsig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); // 송신자 기기의 공개키를 파일에서 읽어오기 (RUD) fis = new FileInputStream(new File(senderName+machineName+".pkey")); size = fis.available(); byte[] s = new byte[size]; fis.read(s); fis.close(); X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(s); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey machinePublicKey = keyFactory.generatePublic(pubKeySpec); // 송신자의 기기인증서명 검증 (RUD) m1 = (senderName+machineName).getBytes(charset); m2 = machinePublicKey.getEncoded(); result = rsaVerify(m1,m2,s1,senderCert.getPublicKey()); System.out.println(" - "+senderName+machineName+"의 기기인증서명 유효성 검증 : "+result); // 수신된 파일에서 전자서명값 읽어오기 fis = new FileInputStream(new File(senderName+machineName+".sig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); message = "전자서명 테스트"; result = rsaVerify(message.getBytes(charset),s1,machinePublicKey); System.out.println(" - 전자서명의 유효성 검증 : "+result); System.out.println("5.3 전자서명 검증 완료 "); System.out.println(); } // 메뉴 6. 사용자의 기기 사이의 전자봉투 테스트 // 송신자 기기 (SUD), 수신자 기기 (RUD) 간의 프로토콜 // 송신자 기기는 자신의 기기의 개인키로 서명하고 수신자 기기의 공개키로 암호화하여 전송 // 수신자 기기는 자신의 기기의 개인키로 복호화하고 송신자 기기의 공개키로 서명을 검증 public static void TestEnvelope(String senderName, String senderMachineName, String receiverName, String receiverMachineName) throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException, UnrecoverableKeyException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, SignatureException, NoSuchProviderException, InvalidKeySpecException { FileInputStream fis; FileOutputStream fos; KeyStore ks; byte[] m1; // 사용자명+기기명 바이트스트림 byte[] m2; // 기기의 공개키 바이트스트림 byte[] s0; // 기기인증서명 byte[] s1=null; // 기기인증서명 (파일에서 읽어온 것) boolean result; // 기기인증서명 검증 결과 int size; // 파일에서 바이트스트림 읽어올때 크기 char[] code = {'s','e','c','r','e','t','c','o','d','e'}; // 개인키 암호화를 위한 키 코드 설정. 편의상 고정하였음 // 6.1 송신자의 키 읽어오기 (SUD) fis = new FileInputStream(new File(senderName+senderMachineName+".key")); ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(fis,code); // 파일에서 읽어와서 키스토어에 로드 fis.close(); PrivateKey senderMachinePrivateKey = (PrivateKey)ks.getKey(senderName+senderMachineName+"PrivateKeyAlias",code); // 키스토어에서 개인키를 읽어올때 암호화 키 코드 필요 System.out.println(" - 송신자의 개인키 읽어오기 "); // 수신자 PKMS의 인증서 읽어오기 (RUD) CertificateFactory cf = CertificateFactory.getInstance("X.509"); fis = new FileInputStream(new File(receiverName+".der")); X509Certificate receiverCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); System.out.println(" - 수신자의 인증서 읽어오기 "); // 인증기관의 인증서 읽어오기 fis = new FileInputStream(new File("inter.der")); X509Certificate interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); System.out.println(" - 인증기관의 인증서 읽어오기 "); // 인증서의 유효성 검증 receiverCert.checkValidity(); receiverCert.verify(interCert.getPublicKey()); // 사용자 인증서의 유효성 검증 System.out.println(" - 수신자 인증서의 유효성 검증 : "); // 수신자의 기기인증서명 읽어오기 (RUD) fis = new FileInputStream(new File(receiverName+receiverMachineName+".dsig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); System.out.println(" - 수신자의 기기인증서명 읽어오기 "); // 수신자 기기의 공개키를 파일에서 읽어오기 (RUD) fis = new FileInputStream(new File(receiverName+receiverMachineName+".pkey")); size = fis.available(); byte[] s = new byte[size]; fis.read(s); fis.close(); X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(s); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey receiverMachinePublicKey = keyFactory.generatePublic(pubKeySpec); System.out.println(" - 수신자의 기기공개키를 파일에서 읽어오기 "); // 수신자의 기기인증서명 검증 (RUD) m1 = (receiverName+receiverMachineName).getBytes(); m2 = receiverMachinePublicKey.getEncoded(); result = rsaVerify(m1,m2,s1,receiverCert.getPublicKey()); System.out.println(" - "+receiverName+receiverMachineName+"의 기기인증서명 유효성 검증 : "+result); System.out.println("6.1 송신자의 키 준비 완료 "); // 6.2 전자봉투 생성하기 (SUD) // 송신자 기기의 기기개인키로 전자서명 생성 String message = "전자봉투 테스트 (전자서명+암호화)"; Charset charset = Charset.forName("UTF-8"); byte[] sigMessage = rsaSign(message.getBytes(charset), senderMachinePrivateKey); // 메시지에 대해 기기개인키로 서명. // 서명값을 파일로 저장 fos = new FileOutputStream(new File(senderName+senderMachineName+".sig")); // 서명문을 파일로 저장 fos.write(sigMessage); fos.close(); System.out.println(" - 송신자기기의 기기개인키로 서명문 생성 "); // 수신자 기기의 기기공개키로 암호화 byte[] ct; // 암호문 ct = rsaEncrypt(message.getBytes(charset), receiverMachinePublicKey); fos = new FileOutputStream(new File(receiverName+receiverMachineName+".enc")); // 암호문을 파일로 저장 fos.write(ct); fos.close(); System.out.println(" - 수신자기기의 기기공개키로 암호문 생성 "); // 메시지+서명문+암호문을 함께 수신자에게 전송 (SUD->RUD) System.out.println("6.2 전자봉투(메시지+서명문+암호문)를 수신자에게 전송 "); // 6.3 전자봉투 검증하기 (RUD) // 송신자 PKMS의 인증서 읽어오기 (RUD) cf = CertificateFactory.getInstance("X.509"); fis = new FileInputStream(new File(senderName+".der")); X509Certificate senderCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 인증기관의 인증서 읽어오기 fis = new FileInputStream(new File("inter.der")); interCert = (X509Certificate)cf.generateCertificate(fis); // 파일에서 읽어서 인증서 형식으로 할당 fis.close(); // 인증서의 유효성 검증 senderCert.checkValidity(); senderCert.verify(interCert.getPublicKey()); // 사용자 인증서의 유효성 검증 System.out.println(" - 송신자 인증서의 유효성 검증 : "); // 송신자의 기기인증서명 읽어오기 (RUD) fis = new FileInputStream(new File(senderName+senderMachineName+".dsig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); // 송신자 기기의 공개키를 파일에서 읽어오기 (RUD) fis = new FileInputStream(new File(senderName+senderMachineName+".pkey")); size = fis.available(); s = new byte[size]; fis.read(s); fis.close(); pubKeySpec = new X509EncodedKeySpec(s); keyFactory = KeyFactory.getInstance("RSA"); PublicKey senderMachinePublicKey = keyFactory.generatePublic(pubKeySpec); // 송신자의 기기인증서명 검증 (RUD) m1 = (senderName+senderMachineName).getBytes(charset); m2 = senderMachinePublicKey.getEncoded(); result = rsaVerify(m1,m2,s1,senderCert.getPublicKey()); System.out.println(" - "+senderName+senderMachineName+"의 기기인증서명 유효성 검증 : "+result); // 암호문 읽어와서 복호화하기 // 암호문을 파일에서 읽어옴 fis = new FileInputStream(new File(receiverName+receiverMachineName+".enc")); size = fis.available(); byte[] ct1 = new byte[size]; fis.read(ct1); fis.close(); // 수신자 기기의 개인키 읽어오기. fis = new FileInputStream(new File(receiverName+receiverMachineName+".key")); ks = KeyStore.getInstance(KeyStore.getDefaultType()); ks.load(fis,code); // 파일에서 읽어와서 키스토어에 로드 fis.close(); PrivateKey receiverMachinePrivateKey = (PrivateKey)ks.getKey(receiverName+receiverMachineName+"PrivateKeyAlias",code); // 키스토어에서 개인키를 읽어올때 암호화 키 코드 필요 byte[] pt1 = rsaDecrypt(ct1,receiverMachinePrivateKey); String decryptedText = new String(pt1, charset); System.out.println(" - 복호화된 메시지 : "+decryptedText); // 수신된 파일에서 전자서명값 읽어오기 fis = new FileInputStream(new File(senderName+senderMachineName+".sig")); size = fis.available(); s1 = new byte[size]; fis.read(s1); fis.close(); result = rsaVerify(message.getBytes(charset),s1,senderMachinePublicKey); System.out.println(" - 전자서명의 유효성 검증 : "+result); System.out.println("6.3 전자봉투 검증 완료 "); System.out.println(); } // MAIN 함수 public static void main(String[] args) throws IOException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException, UnrecoverableKeyException, InvalidKeyException, KeyStoreException, NoSuchAlgorithmException, CertificateException, SignatureException, NoSuchProviderException{ // BouncyCastle Provider 추가 Security.addProvider(new BouncyCastleProvider()); // 프로바이더 추가 // 파일 저장시 확장자 정리 // *.der : 인증서 // *.crl : 인증서취소목록 // *.key : 개인키를 키스토어에 저장 // *.pkey : 공개키를 바이트스트림으로 파일에 저장 // *.rsig : 인증서발급요청서명을 파일에 저장 // *.dsig : 기기인증서명을 바이트스트림으로 파일에 저장 // *.enc : 암호문을 바이트스트림으로 파일에 저장 // *.sig : 서명문을 바이트스트림으로 파일에 저장 int choice=1; Scanner a = new Scanner(System.in); int b; String userName; String machineName; String senderName; String senderMachineName; String receiverName; String receiverMachineName; do { System.out.println(); System.out.println("PKMS 시뮬레이터 "); System.out.println("============= "); System.out.println("1. 인증기관 설정 (CA)"); System.out.println("2. 사용자 인증서 발급 (CA<->PKMS) "); System.out.println("3. 사용자 기기에 자체확장인증서명 발급 (PKMS<->UD) "); System.out.println("4. 암호화/복호화 테스트 (SUD->RUD)"); System.out.println("5. 서명/검증 테스트 (SUD->RUD)"); System.out.println("6. 전자봉투 테스트 (SUD->RUD)"); System.out.println("7. 끝내기 "); System.out.println(); System.out.print("선택해 주세요 : "); b = a.nextInt(); switch (b) { case 1: // 1. 인증기관 설정 System.out.println("1. 인증기관 설정 (CA)"); InitializeCA(); break; case 2: // 2. 사용자 인증서 발급 System.out.println("2. 사용자 인증서 발급 (CA<->PKMS) "); System.out.print(" - 사용자명 : "); userName = a.next(); IssueCert(userName); break; case 3: // 3. 사용자 기기에 기기인증서명 발급 System.out.println("3. 사용자 기기에 자체확장인증서명 발급 (PKMS<->UD) "); System.out.print(" - 사용자명 : "); userName = a.next(); System.out.print(" - 사용자기기명 : "); machineName = a.next(); SetupDevice(userName, machineName); break; case 4: // 4. 암호화/복호화 테스트 System.out.println("4. 암호화/복호화 테스트 (SUD->RUD)"); System.out.print(" - 수신자명 : "); userName = a.next(); System.out.print(" - 수신자기기명 : "); machineName = a.next(); TestEncryption(userName, machineName); break; case 5: // 5. 서명/검증 테스트 System.out.println("5. 서명/검증 테스트 (SUD->RUD)"); System.out.print(" - 송신자명 : "); userName = a.next(); System.out.print(" - 송신자기기명 : "); machineName = a.next(); TestSignature(userName, machineName); break; case 6: // 6. 전자봉투 테스트 - 송신자의 서명 후 수신자의 공개키로 암호화 System.out.println("6. 전자봉투 테스트 (SUD->RUD)"); System.out.print(" - 송신자명 : "); senderName = a.next(); System.out.print(" - 송신자기기명 : "); senderMachineName = a.next(); System.out.print(" - 수신자명 : "); receiverName = a.next(); System.out.print(" - 수신자기기명 : "); receiverMachineName = a.next(); TestEnvelope(senderName, senderMachineName, receiverName, receiverMachineName); break; case 7: // 7. 끝내기 System.out.println("\n프로그램을 종료합니다. 감사합니다. \n "); break; } } while (b!=7); } }