암복호화프로그램

프로그램용도	구현할 Java인터페이스	적용할 설정화면
암복호화프로그램	SecurityBlockProcess	기본설정관리>암호화정보

암복호화 프로그램은 기관 및 시스템에서 암복호화를 사용하는 경우 개발하여 적용한다.

개발방법

만일, BXI에서 제공하는 SEED-256, ARIA-256, AES-256, T-DES 등의 기본 암호화 알고리즘을 사용하는 경우에는 별도의 프로그램 개발 없이 BXI에서 제공하는 프로그램을 사용한다. (ex. AesCipher, AesSecurity 등)

암호화 API

전문이나 특정 필드의 데이터를 암호화하고 Encoding한다.

@Override
public byte[] encrypt(String secretKey, SecurityBlockTypeEnum blockType,
        EncodingDecodingWayEnum encoding, byte[] textMessage) throws Exception {

    // If the library is not loaded, loading
    if (!loadFlag) {
        return null;
    }

    String message = new String(textMessage, CharsetUtil.DEFAULT_CHARSET);
    String msgLen = message.substring(8, 16);
    int len = Integer.parseInt(msgLen);

    logger.debug("std Message Len [{}], textMessage Len [{}]", len, textMessage.length);

    if (len == textMessage.length) {
        return textMessage;
    }

    byte[] textByte = new byte[textMessage.length - len];
    System.arraycopy(textMessage, len, textByte, 0, textMessage.length - len);

    /** encrypt Library Call */
    byte[] secretMessage = CryptionBlockProcessImpl.encrypt(secretKey, textByte, textByte.length);
    if (ObjectUtil.isEmpty(secretMessage)) {
        return textMessage;
    }

    /** encrypt Message Composit */
    byte[] array = new byte[secretMessage.length + len];
    System.arraycopy(textMessage, 0, array, 0, len);
    System.arraycopy(secretMessage, 0, array, len, secretMessage.length);

    return EncDecodingUtil.encoding(encoding, array);
}

Native로 개발된 암호화 모듈을 호출하여 암호화하고, Encoding 종류에 따라서 Encoding한다. 암호화 시작 위치는 전문의 길이부를 제외하고 암호화 한다.

☑ 입력

• secretKey : 암호화 키
• blockType : textMessage를 암호화할 때 사용할 Block 타입
• encoding : 암호화 후 암호화된 데이터를 Encoding하는 방식
• textMessage : 일반 텍스트 데이터

☑ 출력

• 암호화하여 Encoding한 데이터

복호화 API

암호화된 데이터를 Decoding하고 복호화한다.

@Override
public byte[] decrypt(String secretKey, SecurityBlockTypeEnum blockType,
        EncodingDecodingWayEnum decoding, byte[] secretMessage) throws Exception {

    // If the library is not loaded, loading
    if (!loadFlag) {
        return null;
    }

    byte[] inBytes = EncDecodingUtil.decoding(decoding, secretMessage);
    String message = new String(inBytes, CharsetUtil.DEFAULT_CHARSET);
    String msgLen = message.substring(8, 16);
    int len = Integer.parseInt(msgLen);

    logger.debug("std Message Len [{}], secretMessage Len [{}]", len, secretMessage.length);

    if (len == secretMessage.length) {
        return secretMessage;
    }

    byte[] secretByte = new byte[secretMessage.length - len];
    System.arraycopy(secretMessage, len, secretByte, 0, secretMessage.length - len);

    /** decrypt Library Call */
    byte[] plainMessage = CryptionBlockProcessImpl.decrypt(secretKey, secretByte, secretByte.length);
    if (ObjectUtil.isEmpty(plainMessage)) {
        return secretMessage;
    }

    /** decrypt Message Composit */
    byte[] array = new byte[plainMessage.length + len];

    /** Total Message Len */
    String value = String.valueOf(array.length);
    value = ConversionUtil.numericToString(value, 8);
    System.arraycopy(value.getBytes(CharsetUtil.DEFAULT_CHARSET), 0, array, 0, 8);

    System.arraycopy(secretMessage, 8, array, 8, len - 8);
    System.arraycopy(plainMessage, 0, array, len, plainMessage.length);

    return array;
}

먼저 암호화된 데이터를 Decoding하고 Native로 개발된 복호화 모듈을 호출하여 복호화한다. 복호화 시작 위치는 전문의 길이부를 제외하고 복호화 한다.

☑ 입력

• secretKey : 복호화 키
• blockType : secretMessage를 복호화할 때 사용할 Block 타임
• decoding : 복호화 전 암호화된 데이터를 Decoding하는 방식
• secretMessage : 암호화된 데이터

☑ 출력

• 복호화 데이터

전체 예제

import java.nio.charset.Charset;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import bxi.api.SecurityBlockProcess;
import bxi.common.utility.CharsetUtil;
import bxi.common.utility.ObjectUtil;
import bxi.parser.conversion.ConversionUtil;

@Component
public class CryptionBlockProcessImpl implements SecurityBlockProcess {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    /** Library name */
    private static final String LIBRARY_NAME = "vicc";

    /** Encryption function */
    private native static byte[] encrypt(String ucDerivationData, byte[] plainStr, int plainLen);

    /** Decryption function */
    private native static byte[] decrypt(String ucDerivationData, byte[] encStr, int encLen);

    /** Library loading whether */
    private static boolean loadFlag = false;

    /** Encryption/Decryption library loading */
    static {
        try {
            System.loadLibrary(LIBRARY_NAME);
            loadFlag = true;
        } catch (Exception e) {
            loadFlag = false;
        }
    }

    @Override
    public byte[] encrypt(String secretKey, String textMessage, String charsetName) throws Exception {
        return encrypt(secretKey, SecurityBlockTypeEnum.CBC, EncodingDecodingWayEnum.NONE,
                textMessage, charsetName);
    }

    @Override
    public byte[] encrypt(String secretKey, byte[] textMessage) throws Exception {
        return encrypt(secretKey, SecurityBlockTypeEnum.CBC, EncodingDecodingWayEnum.NONE,
                textMessage);
    }

    @Override
    public byte[] encrypt(String secretKey, SecurityBlockTypeEnum blockType,
            EncodingDecodingWayEnum encoding, String textMessage, String charsetName)
            throws Exception {

        Charset charset = (ObjectUtil.isEmpty(charsetName))
                ? CharsetUtil.DEFAULT_CHARSET : CharsetUtil.getCharset(charsetName);
        byte[] message = textMessage.getBytes(charset);

        return encrypt(secretKey, blockType, encoding, message);
    }

    @Override
    public byte[] encrypt(String secretKey, SecurityBlockTypeEnum blockType,
            EncodingDecodingWayEnum encoding, byte[] textMessage) throws Exception {

        // If the library is not loaded, loading
        if (!loadFlag) {
            return null;
        }

        String message = new String(textMessage, CharsetUtil.DEFAULT_CHARSET);
        String msgLen = message.substring(8, 16);
        int len = Integer.parseInt(msgLen);

        logger.debug("std Message Len [{}], textMessage Len [{}]", len, textMessage.length);

        if (len == textMessage.length) {
            return textMessage;
        }

        byte[] textByte = new byte[textMessage.length - len];
        System.arraycopy(textMessage, len, textByte, 0, textMessage.length - len);

        /** encrypt Library Call */
        byte[] secretMessage = CryptionBlockProcessImpl.encrypt(secretKey, textByte, textByte.length);
        if (ObjectUtil.isEmpty(secretMessage)) {
            return textMessage;
        }

        /** encrypt Message Composit */
        byte[] array = new byte[secretMessage.length + len];
        System.arraycopy(textMessage, 0, array, 0, len);
        System.arraycopy(secretMessage, 0, array, len, secretMessage.length);

        return EncDecodingUtil.encoding(encoding, array);
    }

    @Override
    public byte[] decrypt(String secretKey, String secretMessage, String charsetName) throws Exception {
        return decrypt(secretKey, SecurityBlockTypeEnum.CBC, EncodingDecodingWayEnum.NONE,
                secretMessage, charsetName);
    }

    @Override
    public byte[] decrypt(String secretKey, byte[] secretMessage) throws Exception {
        return decrypt(secretKey, SecurityBlockTypeEnum.CBC, EncodingDecodingWayEnum.NONE,
                secretMessage);
    }

    @Override
    public byte[] decrypt(String secretKey, SecurityBlockTypeEnum blockType,
            EncodingDecodingWayEnum decoding, String secretMessage, String charsetName)
            throws Exception {

        Charset charset = (ObjectUtil.isEmpty(charsetName))
                ? CharsetUtil.DEFAULT_CHARSET : CharsetUtil.getCharset(charsetName);
        byte[] message = secretMessage.getBytes(charset);

        return decrypt(secretKey, blockType, decoding, message);
    }

    @Override
    public byte[] decrypt(String secretKey, SecurityBlockTypeEnum blockType,
            EncodingDecodingWayEnum decoding, byte[] secretMessage) throws Exception {

        // If the library is not loaded, loading
        if (!loadFlag) {
            return null;
        }

        byte[] inBytes = EncDecodingUtil.decoding(decoding, secretMessage);
        String message = new String(inBytes, CharsetUtil.DEFAULT_CHARSET);
        String msgLen = message.substring(8, 16);
        int len = Integer.parseInt(msgLen);

        logger.debug("std Message Len [{}], secretMessage Len [{}]", len, secretMessage.length);

        if (len == secretMessage.length) {
            return secretMessage;
        }

        byte[] secretByte = new byte[secretMessage.length - len];
        System.arraycopy(secretMessage, len, secretByte, 0, secretMessage.length - len);

        /** decrypt Library Call */
        byte[] plainMessage = CryptionBlockProcessImpl.decrypt(secretKey, secretByte, secretByte.length);
        if (ObjectUtil.isEmpty(plainMessage)) {
            return secretMessage;
        }

        /** decrypt Message Composit */
        byte[] array = new byte[plainMessage.length + len];

        /** Total Message Len */
        String value = String.valueOf(array.length);
        value = ConversionUtil.numericToString(value, 8);
        System.arraycopy(value.getBytes(CharsetUtil.DEFAULT_CHARSET), 0, array, 0, 8);

        System.arraycopy(secretMessage, 8, array, 8, len - 8);
        System.arraycopy(plainMessage, 0, array, len, plainMessage.length);

        return array;
    }
}