으랏차

전자서명

으랏차 — Thu, 5 Nov 2015 11:00:23 +0900

전자서명

１ 내용

가) 개인 키와 함께 생성된 메시지 다이제스트

나) 서명

다) 서명 검증

２ 목적

가) 무결성

① 데이터에 대해서 바뀌지 않았다는 것을 증명

② 데이터와 메시지 다이제스트 두 개를 다 바꿀 수 있음

③ 다이제스트를 개인키로 서명하면 이것은 불가능해 짐

나) 인증

① 개인 키의 소유자만이 데이터에 서명할 수 있음

② 키가 안전하다면 사용자가 실제로 서명했다는 것을 확신할 수 있음

３ 활용

가) 계약서에 서명

① 1999년 7월부터 ‘전자서명법’이 발효됨

② 기존의 일반 종이문서에 사용되는 인감이나 서명과 같은 법적 효력을 갖게 됨

나) 이메일 서명

① S/MIME나 PGP를 사용해서 개인 키로 이메일을 서명할 수 있음

다) 타임서버 생성

① 타임 스탬프는 데이터에 시간과 함께 서명해서 어떤 특정 시간에 정보가 존재했는지를 증명

라) 서버 승인

① 요청에 서명을 하면 사용자가 서버가 특정한 개인 키를 가졌는지 확인 가능

４ RSA vs. DSA

가) RSA

① 서명을 검증하는데 빠름

나) DSA(Digital Signature Algorithm)

① RSA에서 서명하는 것과 비슷하지만 암호화 기능은 없음

② 서명을 만드는데 빠름

５ 자바의 전자 서명

가) java.security.Signature

① getInstance() : 알고리즘 이름을 인자로 해서 객체의 인스턴스 획득

② initSign() : 개인 키를 인자로 서명

③ initVerify() : 공개 키를 인자로 검증

④ update() : 데이터를 전달하여 서명/검증을 수행

⑤ sign() : 전자서명을 반환

⑥ verify() : 전자서명의 유효성을 반환

６ 간단한 전자서명 예제

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.Signature;

import java.security.SignatureException;

import com.Ostermiller.util.Base64;

public class SignatureExample {

public static void main(String[] args) throws Exception{

//RSA 키 쌍 생성

System.out.println("RSA 키 쌍 생성...");

KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");

kpg.initialize(1024);

KeyPair keyPair = kpg.genKeyPair();

System.out.println("RSA 키 쌍 생성 완료");

// 서명할 데이터

byte[] data = "i love you.".getBytes("UTF-8");

// 서명을 위해 Signatrue 객체 생성 및 개인 키로 초기화

Signature sig = Signature.getInstance("MD5WithRSA");

sig.initSign(keyPair.getPrivate());

sig.update(data);

// 실제 서명

byte[] signaturedBytes = sig.sign();

System.out.println("전자서명된 데이타 : " + Base64.encode(signaturedBytes));

// 전자서명 검증

sig.initVerify(keyPair.getPublic());

sig.update(data);

boolean verified = false;

try {

verified = sig.verify(signaturedBytes);

} catch (SignatureException e) {

verified = false;

System.out.println("전자서명 형식에 문제가 발생하였습니다.");

e.printStackTrace();

}

if(verified)

System.out.println("전자서명 검증 성공");

else

System.out.println("전자서명 검증 실패");

}

７ 전자 서명의 한계

가) 검증을 위해서 공개 키가 필요

나) 공개 키의 소유자를 확신하기가 힘듬

다) 전자 인증서로 문제 해결

MAC

으랏차 — Thu, 5 Nov 2015 10:59:33 +0900

메시지 인증 코드(MAC)

１ 내용

가) 키가 있는 메시지 다이제스트

나) 안전하지 않은 네트워크를 통해 수신된 데이터를 인증할 때

다) 수신자와 송신자가 비밀 키를 교환하여 이 키를 이용하여 검증

라) SSL에 많이 사용됨

마) 비밀 키를 공유해야 하는 것이 문제

바) 수신측에서 데이터 검증

사) HMAC(Hashed Message Authentication Code)라 불리는 암호화 해쉬 함수에 기반

아) Sun JCE에서 제공하는 HMAC 함수

① HmacMD5

② HmacSHA1

２ 사용방법

가) javax.crypto.Mac

① Cipher와 MessageDigest가 합쳐진 것

나) 예제

import java.security.SecureRandom;

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import com.Ostermiller.util.Base64;

public class MACExample {

public static void main(String[] args) throws Exception{

SecureRandom random = new SecureRandom();

byte[] keyBytes = new byte[20];

random.nextBytes(keyBytes);

SecretKeySpec key = new SecretKeySpec(keyBytes, "HMACSHA1");

System.out.println("Key: " + Base64.encode(key.getEncoded()));

//Mac 인스턴스를 획득하고 초기화한다.

Mac mac = Mac.getInstance("HmacSHA1");

mac.init(key);

mac.update("I LOVE YOU!".getBytes("UTF8"));

byte[] result = mac.doFinal();

System.out.println("MAC: " + Base64.encode(result));

}

MessageDigest

으랏차 — Thu, 5 Nov 2015 10:58:40 +0900

자세한 내용을 알고 싶은 분은 다음의 블로그를 참조하세요

http://blog.naver.com/dury00?Redirect=Log&logNo=130044978311

１ 내용

가) 일종의 데이터 지문

나) 데이터가 바뀌지 않았다는 것을 증명

다) 데이터의 길이에 상관없이 보통 16 또는 20byte

라) FTP파일 검증에 많이 사용

마) 해쉬를 이용

바) 한 방향 변환이고 역으로는 불가능

２ 자바에서의 메시지 다이제스트 사용

가) java.security.MessageDigest

① getInstance()로 인자 생성

② MD5, SHA-1이 주로 사용됨

나) update()

① 데이터를 해쉬 함

다) digest()

① 바이트 배열로 해쉬를 반환

② 적은 데이터일 경우 digest에 직접 입력 가능

라) 파일의 메시지 다이제스트 계산

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.io.IOException;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import com.Ostermiller.util.Base64;

public class DigestFile {

public static void main(String[] args) throws NoSuchAlgorithmException, IOException {

MessageDigest md = MessageDigest.getInstance("MD5");

BufferedInputStream in = new BufferedInputStream(new FileInputStream("c:\\test.txt"));

int theByte = 0;

while((theByte = in.read()) != -1)

md.update((byte)theByte);

in.close();

byte[] theDigest = md.digest();

System.out.println(Base64.encode(theDigest));

}

마) 실행결과

① test.txt 파일에는 ‘this is a test file’이 들어 있음 : [B@1a758츄

② ‘this is a test file.’로 수정한 결과 : [B@1b67f74

바) 스트림에서의 메시지 다이제스트

① DigestInputStream & DigestOutputStream

MessageDigest messageDigest = MessageDigest.getInstance(“MD5”);

DigestOutputStream output = new

DigestOutputStream(existingOutputStream, messageDigest);

② 출력에 쓰는 모든 바이트가 자동으로 메시지 다이제스트를 계산할 때 사용됨

③ 예제

import java.io.BufferedInputStream;

import java.io.FileInputStream;

import java.security.DigestInputStream;

import java.security.MessageDigest;

import com.Ostermiller.util.Base64;

public class DigestStreamExample {

public static void main(String[] args) throws Exception{

MessageDigest md = MessageDigest.getInstance("MD5");

BufferedInputStream in = new BufferedInputStream(new FileInputStream("c:\\test.txt"));

//DigestInputStream을 생성한다.

DigestInputStream digestIn = new DigestInputStream(in, md);

// 모든 데이터를 읽어들인다.

while(digestIn.read() != -1);

byte[] theDigest = md.digest();

System.out.println(Base64.encode(theDigest));

}

３ 패스워드 인증

가) 의미

① 패스워드를 해쉬하여 저장할 경우 복호화는 불가능하지만 모든 가능한 패스워드를 해쉬한 다음 비교해서 추즉하는게 가능함

② 이런 공격을 막기 위해 salt와 패스워드를 같이 저장해야 함

③ 서버가 실제 패스워드를 알 필요 없이 사용자가 정한 패스워드를 검증하는게 목적

나) 패스워드 저장

① 랜덤 salt 생성하여 패스워드 앞에 붙임

② 이것을 해쉬함

③ 패스워드 입력될 때마다 비교를 위해 salt와 해쉬 결과를 붙여서 저장

다) 패스워드 인증

① 저장된 패스워드의 salt와 사용자가 입력한 패스워드를 합친다.

② salt와 패스워드를 해쉬한다.

③ 결과 해쉬값을 파일에 저장된 것을 비교한다. 같다면 패스워드가 같은 것이다.

라) 예제

import java.io.ByteArrayOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.security.MessageDigest;

import java.security.SecureRandom;

import java.util.Arrays;

public class Passwordauthenticator {

public static void main(String[] args) throws Exception{

createPassword("iloveyou");

authenticatePassword("iloveyou");

}

private static void createPassword(String password) throws Exception {

// salt 생성

SecureRandom random = new SecureRandom();

byte[] salt = new byte[12];

random.nextBytes(salt);

// salt와 패스워드를 붙여서 해쉬한다.

MessageDigest md = MessageDigest.getInstance("MD5");

md.update(salt);

md.update(password.getBytes("UTF-8"));

byte[] digest = md.digest();

// salt와 해쉬 결과를 파일에 저장한다.

FileOutputStream fos = new FileOutputStream("c:\\password.txt");

fos.write(salt);

fos.write(digest);

fos.close();

}

private static void authenticatePassword(String password) throws Exception {

// 파일을 읽어들인다.

ByteArrayOutputStream baos = new ByteArrayOutputStream();

FileInputStream fis = new FileInputStream("c:\\password.txt");

int theByte = 0;

while((theByte = fis.read()) != -1)

baos.write(theByte);

fis.close();

byte[] hashedPasswordWithSalt = baos.toByteArray();

baos.reset();

//salt를 얻는다.

byte[] salt = new byte[12];

System.arraycopy(hashedPasswordWithSalt, 0, salt, 0, 12);

// salt와 입력한 패스워드를 붙여서 해쉬한다.

MessageDigest md = MessageDigest.getInstance("MD5");

md.update(salt);

md.update(password.getBytes("UTF-8"));

byte[] digest = md.digest();

// 파일에 있는 내용과 비교한다.

byte[] digestInFile = new byte[hashedPasswordWithSalt.length-12];

System.arraycopy(hashedPasswordWithSalt, 12, digestInFile, 0, hashedPasswordWithSalt.length-12);

if(Arrays.equals(digest, digestInFile))

System.out.println("Password matches.");

else

System.out.println("Password does not matches.");

}

RSA 암호화

으랏차 — Thu, 5 Nov 2015 10:57:33 +0900

RSA 파일 암호화

１ RSA 키 쌍 생성

２ 공개 키로 파일을 암호화

가) RSA 키의 인코딩

① X.509를 사용하여 인코딩 사용(공개 키와 인증서를 전달할 때 사용하는 공개 형식)

② 개인 키는 PKCS#8로 인코딩

③ 공개/개인 키든 getEncoded()를 호출하면 자동으로 인코딩 됨

나) RSA 키의 디코딩

① 인코딩된 키의 스펙 객체를 생성

② KeyFactory를 사용하여 적절한 키 타입의 인스턴스를 활성화

③ 공개 키 디코딩

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);

PublicKey publicKey = keyFactory.generatePublic(keySpec);

④ 개인 키의 디코딩

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance(“RSA”);

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

다) 암호화된 파일 형식

① 포맷

키의 길이

암호화된 키

초기화백터(16바이트)

암호문서

라) 예제

private static void createKey(String password) throws Exception {

// RSA 키 쌍 생성

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");

keyPairGenerator.initialize(1024);

KeyPair keyPair = keyPairGenerator.genKeyPair();

//공개키를 파일에 쓴다.

byte[] publicKeyBytes = keyPair.getPublic().getEncoded();

FileOutputStream fos = new FileOutputStream("c:\\publicKey");

fos.write(publicKeyBytes);

fos.close();

// 개인 키를 암호화한 후에 파일에 쓴다.

byte[] privateKeyBytes = passwordEncrypt(password.toCharArray(), keyPair.getPrivate().getEncoded());

fos = new FileOutputStream("c:\\privateKey");

fos.write(publicKeyBytes);

fos.close();

}

private static byte[] passwordEncrypt(char[] password, byte[] plaintext) throws Exception {

// salt 생성

byte[] salt = new byte[9];

Random random = new Random();

random.nextBytes(salt);

// PBE 키와 사이퍼 생성

PBEKeySpec keySpec = new PBEKeySpec(password);

SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithSHAAndTwofish-CBC");

SecretKey key = keyFactory.generateSecret(keySpec);

PBEParameterSpec paramSpec = new PBEParameterSpec(salt, ITERATIONS);

Cipher cipher = Cipher.getInstance("PBEWithSHAAndTwofish-CBC");

cipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);

byte[] cipherText = cipher.doFinal(plaintext);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

baos.write(salt);

baos.write(cipherText);

return baos.toByteArray();

}

private static void encrypt(String fileInput) throws Exception {

String publicKeyFileName = "c:\\publicKey";

// 공개 키가 저장된 파일로부터 keyByte의 바이트 배열을 생성한다.

FileInputStream fis = new FileInputStream(publicKeyFileName);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

int theByte = 0;

while((theByte = fis.read()) != -1)

baos.writeTo(baos);

fis.close();

byte[] keyBytes = baos.toByteArray();

baos.close();

// 인코딩된 키를 RSA 공개 키의 인스턴스로 바꾼다.

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

PublicKey publicKey = keyFactory.generatePublic(keySpec);

String fileOutput = fileInput + ENCRYPTED_FILENAME_SUFFIX;

DataOutputStream output = new DataOutputStream(new FileOutputStream(fileOutput));

// RSA 공개 키를 이용하여 세션 키를 암호화할 사이퍼를 생성한다.

Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

rsaCipher.init(Cipher.ENCRYPT_MODE, publicKey);

// 세션 키 생성

KeyGenerator rijndaelKeyGenerator = KeyGenerator.getInstance("Rijndael");

rijndaelKeyGenerator.init(256);

Key rijndaelKey = rijndaelKeyGenerator.generateKey();

// RSA 사이퍼를 이용하여 세션 키를 암호화 하고 파일에 저장한다.

// 키의 길이, 인코딩된 세션 키 형식이다.

byte[] encodedKeyBytes = rsaCipher.doFinal(rijndaelKey.getEncoded());

output.writeInt(encodedKeyBytes.length);

output.write(encodedKeyBytes);

// 초기화 벡터

SecureRandom random = new SecureRandom();

byte[] iv = new byte[16];

random.nextBytes(iv);

//IV를 파일에 쓴다

output.write(iv);

//IV와 생성한 세션 키를 이용하여 파일의 내용을 암호화한다.

IvParameterSpec spec = new IvParameterSpec(iv);

Cipher symmetricCipher = Cipher.getInstance("Rijndael/CBC/PKCS5Padding");

symmetricCipher.init(Cipher.ENCRYPT_MODE, rijndaelKey, spec);

CipherOutputStream cos = new CipherOutputStream(output, symmetricCipher);

FileInputStream input = new FileInputStream(fileInput);

theByte = 0;

while((theByte = input.read()) != -1)

cos.write(theByte);

input.close();

cos.close();

return;

}

３ 개인 키로 복호화

가) 예제

private static byte[] passwordDecrypt(char[] password, byte[] ciphertext) throws Exception {

// salt를 읽는다. 개인키는 8byte salt를 사용했다.

byte[] salt = new byte[8];

ByteArrayInputStream bais = new ByteArrayInputStream(ciphertext);

bais.read(salt, 0 ,8);

byte[] remainingCiphertext = new byte[ciphertext.length-8];

bais.read(remainingCiphertext, 0, ciphertext.length-8);

//PBE 사이퍼를 생성하여 세션 키를 복원한다.

PBEKeySpec keySpec = new PBEKeySpec(password);

SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithSHAAndTwofish-CBC");

SecretKey key = keyFactory.generateSecret(keySpec);

PBEParameterSpec paramSpec = new PBEParameterSpec(salt, ITERATIONS);

Cipher cipher = Cipher.getInstance("PBEWithSHAAndTwofish-CBC");

// 키 복호화

cipher.init(Cipher.DECRYPT_MODE, key, paramSpec);

return cipher.doFinal(remainingCiphertext);

}

private static void decrypt(String password, String fileInput) throws Exception {

String privateKeyFilename = "c:\\privateKey";

// 파일로부터 개인 키를 읽어들인다.

FileInputStream fis = new FileInputStream(privateKeyFilename);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

int theByte = 0;

while((theByte = fis.read()) != -1)

baos.write(theByte);

fis.close();

byte[] keyByte = baos.toByteArray();

baos.close();

// 암호화된 개인 키 바이트를 복원한다.

keyByte = passwordDecrypt(password.toCharArray(), keyByte);

// RSA 개인 키를 복원한다.

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyByte);

KeyFactory keyFactory = KeyFactory.getInstance("RSA");

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

// 개인 키를 이용하여 사이퍼를 생성하고 세션 키를 복호화한다

Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

DataInputStream dis = new DataInputStream(new FileInputStream(fileInput));

byte[] encryptedKeyBytes = new byte[dis.readInt()];

dis.readFully(encryptedKeyBytes);

rsaCipher.init(Cipher.DECRYPT_MODE, privateKey);

byte[] rijndaelKeyByte = rsaCipher.doFinal(encryptedKeyBytes);

SecretKey rijndaelKey = new SecretKeySpec(rijndaelKeyByte, "Rijndael");

byte[] iv = new byte[16];

dis.readFully(iv);

IvParameterSpec spec = new IvParameterSpec(iv);

Cipher cipher = Cipher.getInstance("Rijndael/CBC/PKCS5padding");

cipher.init(Cipher.DECRYPT_MODE, rijndaelKey, spec);

CipherInputStream cis = new CipherInputStream(dis, cipher);

FileOutputStream fos = new FileOutputStream(fileInput + DECRYPTED_FILENAME_SUFFIX);

theByte = 0;

while((theByte = cis.read()) != -1)

fos.write(theByte);

cis.close();

fos.close();

return;

}

나) 복호화 과정

４ 세션 키 암호화를 사용해야 하는 이유

가) 해킹에 대비해, 개인 키를 저장할 때 암호화할 필요가 있다.

나) 세션 키를 사용하면 속도가 훨씬 빨라진다.

다) RSA는 특정 메시지에 대해서 매우 취약하다.

Session key

으랏차 — Thu, 5 Nov 2015 10:56:24 +0900

세션 키 암호화

１ 개념

가) 비대칭 암호화는 대칭 암호화보다 1000배 느림

나) 메시지는 대칭 키로 암호화하고 이 대칭 키가 수신자의 공개키로 암호화됨

다) 암호화된 공개 키는 메시지에 덧붙여서 수신자에게 전달됨

２ 예제

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class SimpleRSAExample {
public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
  String plainText = "iloveyou";
  // 대칭 키 생성
  KeyGenerator keyGenerator = KeyGenerator.getInstance("Blowfish");
  keyGenerator.init(128);
  Key blowfishKey = keyGenerator.generateKey();

  Cipher blowfishCipher = Cipher.getInstance("Blowfish/ECB/PKCS5padding");
  blowfishCipher.init(Cipher.ENCRYPT_MODE, blowfishKey);

  byte[] ciphertext = blowfishCipher.doFinal(plainText.getBytes());

  System.out.println("암호화된 문서 : " + ciphertext);

  // RSA 키 쌍 생성
  KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
  keyPairGenerator.initialize(1024);
  KeyPair keyPair = keyPairGenerator.genKeyPair();

  Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
  rsaCipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());

  //대칭 키의 바이트 획득
  byte[] blowfishKeyBytes = blowfishKey.getEncoded();

  // 대칭 키 바이트를 RSA 개인키로 암호화
  byte[] cipherKeyBytes = rsaCipher.doFinal(blowfishKeyBytes);

  // 수신측에서 동작한다고 가정
  // 암호화된 문서와 암호화된 대칭키가 전달된다고 가정
  // 수신자의 공개키로 키 복호화
  rsaCipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
  byte[] decryptedKeyBytes = rsaCipher.doFinal(cipherKeyBytes);
  SecretKey newBlowfishKey = new SecretKeySpec(decryptedKeyBytes, "Blowfish");

  // 복호화된 대칭키로 전달된 암호문 복호화
  blowfishCipher.init(Cipher.DECRYPT_MODE, newBlowfishKey);
  byte[] decryptedText = blowfishCipher.doFinal(ciphertext);

  System.out.println("복호화된 문서 : " + new String(decryptedText));
}

}

대칭키 암호화

으랏차 — Thu, 5 Nov 2015 10:55:19 +0900

１ 키의 저장

파일 시스템 안에 키를 저장할 경우 이에 대한 보안이 필요

가) 키 래핑(Wrapping)과 언래핑(Unwrapping)

① wrap() 함수 : Cipher 클래스에 있는 함수로 키를 매개변수로 받아서 암호화된 키의 바이트 배열을 반환

cipher.init(Cipher.WRAP_MODE, passwordKey, paramSpec);

byte[] encryptedKeyBytes = cipher.wrap(secretKey);

② unwrap() : 암호화된 키의 바이트 배열을 Key로 반환

cipher.init(Cipher.UNWRAP_MODE, passwordKey, paramSpec);

Key key = cipher.unwrap(encryptedKeyBytes, “Blowfish”, Cipher.SECRET_KEY);

나) 래핑을 하지 않는 키 암호화

① wrap()과 unwrap()이 없다면 Key.getEncoded(), SecretKeySpec을 이용해 암호화

② java.security.Key : 암호화된 키의 바이트 배열을 반환

byte[] keyBytes = myKey.getBytes();

cipher.init(Cipher.ENCRYPT_MODE, passwordKey, paramSpec);

byte[] encryptedKeyBytes = cipher.doFinal(keyBytes);

③ SecretKeySpec : 키를 복호화

cipher.init(Cipher.DECRYPT_MODE, passwordKey, paramSpec);

byte[] keyBytes = cipher.doFinal(encryptedKeyBytes);

SecretKeySpec myKey = new SecretKeySpec(keyBytes, “Blowfish”);

２ 사이퍼 스트림(CipherStream)

가) 표준 입/출력 스트림을 암/복호화를 위한 래퍼 클래스를 제공

① CipherInputStream

② CipherOutputStream

나) 예제

FileInputStream input = new FileInputStream(“plaintext_filename”);

FileOutputStream output = new FileOutputStream(“ciphertext_filename”);

CipherOutputStram cipherOutput = new CipherOutputStream(output, cipher);

int r = 0;

while((r=input.read()) != null)

cipherOutput.write(r);

cipherOutput.close();

output.close();

input.close();

３ IV로 사이퍼 초기화

초기화 백터의 바이트를 생성하기 위해 java.security.SecureRandom을 이용

가) SecureRandom

① 예

byte[] randomBytes = new byte[8];

SecureRandom random = new SecureRandom();

random.nextBytes(randomBytes);

나) IV 생성과 사용

① 생성

IVParameterSpec iv = new IVParameterSpec(randomBytes);

② 사용

Cipher cipher = Cipher.getInstance(“Blowfish/CBC/PCS5PADDing”);

cipher.init(Cipher.ENCRYPT_MODE, key, iv);

다) IV 추적

① 복호화 할 때에도 동일한 IV가 사용되어야 함

② salt와 매우 비슷하며 숨길 필요 없이 암호문에 붙여서 사용함

４ 사이퍼 스트림 예제 – 파일 인코더

가) 사이퍼 스트림을 이용해 파일을 암/복호화

나) 키는 패스워드 기반 암호화로 파일에 저장 및 복호화

다) 4개의 기능을 포함

① createKey() : AES 키를 생성 하고 패스워드를 이용하여 암호화하여 파일에 저장

/**

* 1. 256bit AES(Rijndael)키를 생성

* 2. PBE를 이용하여 생성한 키를 암호화하여 파일에 저장

private static void createKey(char[] password) {

System.out.println("Generating a RijnDael key...");

// AES 대칭 키 생성기 객체 생성

KeyGenerator keyGenerator = null;

try {

keyGenerator = KeyGenerator.getInstance("Rijndael");

} catch (NoSuchAlgorithmException e) {}

// AES 키 생성

keyGenerator.init(256);

Key key = keyGenerator.generateKey();

System.out.println("Done generating the key");

// PBE 시작

// salt 생성

byte[] salt = new byte[8];

SecureRandom random = new SecureRandom();

random.nextBytes(salt);

// password로 PBEKeySpec 생성

PBEKeySpec pbeKeySpec = new PBEKeySpec(password);

SecretKeyFactory keyFactory = null;;

SecretKey pbeKey = null;

try {

keyFactory = SecretKeyFactory.getInstance("PBEWithSHAAndTwofish-CBC");

pbeKey = keyFactory.generateSecret(pbeKeySpec);

} catch (NoSuchAlgorithmException e) {}

catch (InvalidKeySpecException e) {}

// PBEParameterSpec 생성

PBEParameterSpec pbeParamSpec = new PBEParameterSpec(salt, ITERATIONS);

// Cipher 생성 및 초기화

Cipher cipher = null;

byte[] encryptedKeyBytes = null;

try {

cipher = Cipher.getInstance("PBEWithSHAAndTwofish-CBC");

cipher.init(Cipher.ENCRYPT_MODE, pbeKey, pbeParamSpec);

// AES키 암호화

encryptedKeyBytes = cipher.doFinal(key.getEncoded());

} catch (NoSuchAlgorithmException e) {}

catch (NoSuchPaddingException e) {}

catch (InvalidKeyException e) {}

catch (InvalidAlgorithmParameterException e) {}

catch (IllegalBlockSizeException e) {}

catch (BadPaddingException e) {}

FileOutputStream fos;

try {

fos = new FileOutputStream(KEY_FILENAME);

//salt와 암호화된 키 바이트를 쓴다.

fos.write(salt);

fos.write(encryptedKeyBytes);

fos.close();

} catch (FileNotFoundException e) {}

catch (IOException e) {}

}

② loadKey() : 키가 저장된 파일로부터 읽어들여 복호화하여 키를 생성

private static Key loadKey(char[] password) throws Exception {

// 파일로부터 읽어들임

FileInputStream fis = new FileInputStream(KEY_FILENAME);

ByteArrayOutputStream baos = new ByteArrayOutputStream();

int i = 0;

while((i=fis.read()) != -1)

baos.write(i);

fis.close();

byte[] saltAndKeyBytes = baos.toByteArray();

baos.close();

// salt를 분리함. Base64 인코딩을 하지 않았기에 8byte 그대로 유지됨

byte[] salt = new byte[8];

System.arraycopy(saltAndKeyBytes, 0, salt, 0, 8);

// key를 분리함

int length = saltAndKeyBytes.length - 8;

byte[] encryptedKeyBytes = new byte[length];

System.arraycopy(saltAndKeyBytes, 8, encryptedKeyBytes, 0, length);

// PBE 시작

PBEKeySpec pbeKeySpec = new PBEKeySpec(password);

SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithSHAAndTwofish-CBC");

SecretKey pbeKey = keyFactory.generateSecret(pbeKeySpec);

PBEParameterSpec pbeParamSpec = new PBEParameterSpec(salt, ITERATIONS);

// Cipher 생성 및 초기화

Cipher cipher = Cipher.getInstance("PBEWithSHAAndTwofish-CBC");

cipher.init(Cipher.DECRYPT_MODE, pbeKey, pbeParamSpec);

// 키 복호화

byte[] decryptedKeyBytes = cipher.doFinal(encryptedKeyBytes);

SecretKeySpec key = new SecretKeySpec(decryptedKeyBytes, "Rijndael");

return key;

}

③ encrypt() : 사이퍼 스트림을 이용하여 암호화 수행

private static void encrypt(char[] passowrd, String fileInput, String fileOutput) throws Exception {

// key 로드

System.out.println("Loading the key.");

Key key = loadKey(passowrd);

System.out.println("Loaded the key.");

// 사이퍼 생성

Cipher cipher = Cipher.getInstance("Rijndael/CBC/PKCS5Padding");

System.out.println("Initializing SecureRandom...");

// SecureRandom 생성하여 IV 초기화

SecureRandom random = new SecureRandom();

byte[] iv = new byte[16];

random.nextBytes(iv);

// 입력 파일과 출력 파일의 stream을 연다

FileInputStream fis = new FileInputStream(fileInput);

FileOutputStream fos = new FileOutputStream(fileOutput);

// 먼저 출력파일에 iv를 쓴다.

fos.write(iv);

// IvParameterSpec를 생성하고 사이퍼를 생성 및 초기화한다.

IvParameterSpec spec = new IvParameterSpec(iv);

System.out.println("Initializing the cipher...");

cipher.init(Cipher.ENCRYPT_MODE, key, spec);

// 출력 스트림과 사이퍼를 인자로 사이퍼 스트림을 생성한다.

CipherOutputStream cos = new CipherOutputStream(fos, cipher);

System.out.println("Encrypting the file");

// 입력 파일로부터 읽어들여 사이퍼 스트림에다 쓴다.

int theByte = 0;

while((theByte = fis.read()) != -1)

cos.write(theByte);

// 스트림을 모두 닫아준다.

fis.close();

cos.close();

}

④ decrypt() : 사이퍼 스트림을 이용하여 복호화 수행

private static void decrypt(char[] password, String fileInput, String fileOutput) throws Exception {

// key 로드

System.out.println("Loading the key");

Key key = loadKey(password);

System.out.println("Loaded the key.");

// 사이퍼 생성

Cipher cipher = Cipher.getInstance("Rijndael/CBC/PKCS5Padding");

// 입력 파일과 출력 파일의 stream을 연다

FileInputStream fis = new FileInputStream(fileInput);

FileOutputStream fos = new FileOutputStream(fileOutput);

// 입력파일에서 초기화 벡터 16byte를 읽어들인다.

// Base64인코딩을 하지 않았으므로 길이는 그대로다.

byte[] iv = new byte[16];

fis.read(iv);

// IvParameterSpec 생성 및 사이퍼 초기화

IvParameterSpec spec = new IvParameterSpec(iv);

System.out.println("Initializing the cipher...");

cipher.init(Cipher.DECRYPT_MODE, key, spec);

// 입력파일과 사이퍼를 인자로 사이퍼 스트림을 생성한다.

CipherInputStream cis = new CipherInputStream(fis, cipher);

System.out.println("Decrypting the file...");

// 입력파일로 부터 읽어들여 출력파일에 쓴다.

int theByte = 0;

while((theByte = cis.read()) != -1)

fos.write(theByte);

// 스트림을 모두 닫아준다.

cis.close();

fos.close();

}

５ 봉인 객체

가) 사이퍼 또는 키로 객체를 암호화할 수 있는 방법을 제공

나) 암호화 객체 또는 봉인 객체라 불림

다) 예

import java.io.IOException;

import java.security.InvalidKeyException;

import java.security.Key;

import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import javax.crypto.KeyGenerator;

import javax.crypto.NoSuchPaddingException;

import javax.crypto.SealedObject;

public class SealedObjectExample {

public static void main(String[] args) {

String creatiCard = "1234567890";

try {

KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");

Key key = keyGenerator.generateKey();

Cipher cipher = Cipher.getInstance("DESede");

cipher.init(Cipher.ENCRYPT_MODE, key);

System.out.println("Encrypting the Object");

SealedObject so = new SealedObject(creatiCard, cipher);

System.out.println("Decrypting the Object");

//String decryptedCrediteCard = (String) so.getObject(key);

cipher.init(Cipher.DECRYPT_MODE, key);

String decryptedCrediteCard = (String) so.getObject(cipher);

System.out.println("Credit card Number : " + decryptedCrediteCard);

} catch (NoSuchAlgorithmException e) {