/*
 * Copyright (c) 2009 The openGion Project.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.opengion.fukurou.security;

import java.io.File;
// import java.io.FileInputStream;                                                      // 8.5.4.2 (2024/01/12) PMD 7.0.0 AvoidFileStream 対応
import java.io.InputStream;                                                                     // 5.10.9.0 (2019/03/01)
import java.io.IOException;
import java.nio.ByteBuffer;                                                                     // 5.5.2.6 (2012/05/25)
import java.nio.channels.FileChannel;                                           // 5.7.2.1 (2014/01/17)
import java.nio.charset.Charset;                                                        // 5.5.2.6 (2012/05/25)
// import java.nio.file.Files;                                                          // 8.5.4.2 (2024/01/12) PMD 7.0.0 AvoidFileStream 対応
import java.nio.file.OpenOption;                                                        // 8.5.4.2 (2024/01/12) PMD 7.0.0 AvoidFileStream 対応
import java.nio.file.StandardOpenOption;                                        // 8.5.4.2 (2024/01/12) PMD 7.0.0 AvoidFileStream 対応

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.GeneralSecurityException;                          // 5.7.2.1 (2014/01/17)
import java.security.DigestInputStream;                                         // 5.10.9.0 (2019/03/01)

import javax.crypto.spec.SecretKeySpec;
import javax.crypto.Cipher;

import org.opengion.fukurou.system.Closer;                                      // 5.5.2.6 (2012/05/25)
import org.opengion.fukurou.system.OgRuntimeException ;         // 6.4.2.0 (2016/01/29)
import org.opengion.fukurou.system.FileOperation;                       // 8.5.6.0 (2024/02/29) package変更 fukurou.model → fukurou.system
import static org.opengion.fukurou.system.HybsConst.CR;         // 8.1.2.0 (2022/03/10)

/**
 * HybsCryptography は、セキュリティ強化の為の Hybs独自の暗号化クラスです。
 *
 * このクラスは、暗号化キーを受け取り、それに基づいて暗号化/復号化を行います。
 * ここでの暗号化は、秘密キー方式でバイト文字列に変換されたものを、１６進アスキー文字に
 * 直して、扱っています。よって、暗号化/復号化共に、文字列として扱うことが可能です。
 *
 * @og.rev 4.0.0.0 (2005/08/31) 新規追加
 * @og.rev 5.9.10.0 (2019/03/01) クラウドストレージ対応を追加。(Fileクラスを拡張)
 *
 * @og.group ライセンス管理
 *
 * @version  4.0
 * @author   Kazuhiko Hasegawa
 * @since    JDK5.0,
 */
public final class HybsCryptography {
        // 8.5.4.2 (2024/01/12) PMD 7.0.0 AvoidFileStream 対応
        private static final OpenOption[] READ   = { StandardOpenOption.READ };

        private static final String CIPHER_TYPE = "Blowfish" ;
        private final SecretKeySpec sksSpec ;

        /**
         * 数字から１６進文字に変換するテーブルです。
         */
        private static final char[] HEXA_DECIMAL =
                { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                  'a', 'b', 'c', 'd', 'e', 'f' };

        /**
         * プラットフォーム依存のデフォルトの Charset です。
         * プラットフォーム依存性を考慮する場合、エンコード指定で作成しておく事をお勧めします。
         *
         * @og.rev 5.5.2.6 (2012/05/25) findbugs対応
         * @og.rev 8.5.3.2 (2023/10/13) JDK21注意。JDK17までは、Windows-31J だったが、JDK21から、UTF-8 に変更されている。
         */
        private static final Charset DEFAULT_CHARSET = Charset.defaultCharset() ;

        /** 注意：秘密キーは、８の倍数でないといけない。 */
        private static final String HYBS_CRYPT_KEY = "2a5a88891d37ae59" ;

        /**
         * 内部設定の秘密鍵を使用して、暗号化を行うオブジェクトを構築します。
         * ここでの暗号化は、Java標準のセキュリティパッケージを使用しています。
         *
         * @og.rev 6.2.5.0 (2015/06/05) 引数付コンストラクタを使用
         */
        public HybsCryptography() {
                this( HYBS_CRYPT_KEY );
        }

        /**
         * 秘密鍵の文字列を受け取って、暗号化を行うオブジェクトを構築します。
         * ここでの暗号化は、Java標準のセキュリティパッケージを使用しています。
         * 秘密鍵のサイズを、8 の倍数 (32 以上 448 以下) にする必要があります。
         *
         * @og.rev 5.8.8.0 (2015/06/05) null時の挙動はデフォルトキーを利用する
         *
         * @param       cryptKey        暗号化を行う秘密鍵
         */
        public HybsCryptography( final String cryptKey ) {
                // 5.8.8.0 (2015/06/05) null時はデフォルトキーを利用
                final String useKey;
                if( cryptKey == null || cryptKey.length() == 0 ){
                        useKey = HYBS_CRYPT_KEY;
                }
                else{
                        useKey = cryptKey;
                }
                sksSpec = new SecretKeySpec( useKey.getBytes( DEFAULT_CHARSET ), CIPHER_TYPE );
        }

        /**
         * セキュリティカラムのDBTyepに対してHybs独自の暗号化を行います。
         * 暗号化されたデータは、通常 byte 文字ですが、１６進数アスキー文字列に変換
         * したものを返します。
         * この暗号化では、引数が null の場合は、ゼロ文字列を返します。
         *
         * @og.rev 5.7.2.1 (2014/01/17) Exceptionをまとめます。
         *
         * @param       org     暗号化を行う元の文字列
         *
         * @return      暗号化された文字列(HEXADECIMAL化)
         * @og.rtnNotNull
         */
        public String encrypt( final String org ) {
                if( org == null || org.isEmpty() ) { return ""; }

                try {
                        final Cipher cipher = Cipher.getInstance( CIPHER_TYPE );
                        cipher.init( Cipher.ENCRYPT_MODE, sksSpec );
                        final byte[] encrypted = cipher.doFinal( org.getBytes( DEFAULT_CHARSET ) );             // 5.5.2.6 (2012/05/25) findbugs対応

                        return byte2hexa( encrypted );
                }
                // 5.7.2.1 (2014/01/17) Exceptionをまとめます。
                catch( final GeneralSecurityException   ex ) {
                        final String errMsg = "暗号化処理に失敗しました。[" + org + "]"
                                                        + ex.getMessage() ;
                        throw new OgRuntimeException( errMsg,ex );
                }
        }

        /**
         * セキュリティカラムのDBTyepに対してHybs独自の復号化を行います。
         * ここでの復号化は、encrypt で暗号化された文字を戻す場合に使用します。
         * この復号化では、null は復号化できないため、ゼロ文字列を返します。
         *
         * @og.rev 5.7.2.1 (2014/01/17) Exceptionをまとめます。
         *
         * @param       hex     復号化を行う暗号化された１６進数アスキー文字列
         *
         * @return      復号化された元の文字列
         * @og.rtnNotNull
         */
        public String decrypt( final String hex ) {
                if( hex == null || hex.isEmpty() ) { return ""; }

                try {
                        final Cipher cipher = Cipher.getInstance( CIPHER_TYPE );
                        cipher.init( Cipher.DECRYPT_MODE, sksSpec );
                        final byte[] encrypted = hexa2byte( hex );
                        final byte[] decrypted = cipher.doFinal( encrypted );

                        return new String( decrypted,DEFAULT_CHARSET );         // 5.5.2.6 (2012/05/25) findbugs対応
                }
                // 5.7.2.1 (2014/01/17) Exceptionをまとめます。
                catch( final GeneralSecurityException   ex ) {
                        final String errMsg = "復号化処理に失敗しました。[" + hex + "]"
                                                        + ex.getMessage() ;
                        throw new OgRuntimeException( errMsg,ex );
                }
        }

        /**
         * バイト配列を１６進数アスキー文字列に変換します。
         *
         * バイト配列を、２文字の0～9,a～ｆのアスキーに変換されます。
         * これにより、すべての文字を、アスキー化できます。
         * アスキー化で、上位が0F以下の場合でも、0 を出すことで、固定長に変換します。
         *
         * よって、入力バイトの２倍のlength()を持ったStringを作成します。
         *
         * @param       input バイト配列
         *
         * @return      １６進数アスキー文字列
         */
        public static String byte2hexa( final byte[] input ) {
                String rtn = null;
                if( input != null && input.length > 0 ) {
                        final int len = input.length ;
                        final char[] ch = new char[len*2];              // 8.5.4.2 (2024/01/12) PMD 7.0.0 LocalVariableCouldBeFinal
                        for( int i=0; i<len; i++ ) {
                                final int high = (input[i] & 0xf0) >> 4 ;
                                final int low  = input[i] & 0x0f ;
                                ch[i*2]   = HEXA_DECIMAL[high];
                                ch[i*2+1] = HEXA_DECIMAL[low];
                        }
                        // 8.5.4.2 (2024/01/12) PMD 7.0.0 StringInstantiation 対応
//                      rtn = new String(ch);
                        rtn = String.valueOf( ch );
                }
                return rtn;
        }

        /**
         * １６進数アスキー文字列をバイト配列に変換します。
         *
         * ２文字の0～9,a～ｆのアスキー文字列を、バイト配列に変換されます。
         *
         * よって、入力Stringの１/２倍のlengthを持ったバイト配列を作成します。
         *
         * @param       input １６進数アスキー文字列
         *
         * @return      バイト配列
         */
        public static byte[] hexa2byte( final String input ) {
                byte[] rtn = null;
                if( input != null ) {
                        final int len = input.length() ;
                        rtn = new byte[len/2];
                        for( int i=0; i<len/2; i++ ) {
                                char ch = input.charAt( i*2 );
                                final int high = ch < 'a' ? (ch-'0') : (ch-'a'+10) ;
                                ch = input.charAt( i*2+1 );
                                final int low  = ch < 'a' ? (ch-'0') : (ch-'a'+10) ;
                                rtn[i] = (byte)(high << 4 | low);
                        }
                }
                return rtn;
        }

        /**
         * MessageDigestにより、ｼｽﾃﾑ定数に定義されている ﾊｯｼｭｺｰﾄﾞ で
         * ﾊｯｼｭした文字に変換します。
         *
         * 連結後の文字列長は、ﾊｯｼｭｺｰﾄﾞにより異なります。
         *
         * @og.rev 8.1.2.0 (2022/03/10) getMD5参照して新規作成
         *
         * @param       hashCode        ﾊｯｼｭｺｰﾄﾞ (MD5, SHA-1, SHA-256, SHA-512)
         * @param       input           変換前の文字列
         *
         * @return      ﾊｯｼｭｺｰﾄﾞでﾊｯｼｭした文字列
         */
        public static String getHash( final String hashCode, final String input ) {
                String rtn = null;
                if( hashCode != null && input != null ) {
                        try {
                                final MessageDigest md = MessageDigest.getInstance( hashCode );
                                md.update( input.getBytes( DEFAULT_CHARSET ) );                         // 5.5.2.6 (2012/05/25) findbugs対応
                                final byte[] out = md.digest();
                                rtn = byte2hexa( out );
                        }
                        catch( final NoSuchAlgorithmException ex ) {
                                final String errMsg = "MessageDigestで失敗しました。" + CR
                                                        + "ﾊｯｼｭｺｰﾄﾞ=[" + hashCode + "] , 変換前=[" + input + "]" + CR
                                                        + ex.getMessage() ;
                                throw new OgRuntimeException( errMsg,ex );
                        }
                }
                return rtn;
        }

        /**
         * MessageDigestにより、ｼｽﾃﾑ定数に定義されている ﾊｯｼｭｺｰﾄﾞ で
         * ﾊｯｼｭした文字に変換します。
         *
         * 連結後の文字列長は、ﾊｯｼｭｺｰﾄﾞにより異なります。
         *
         * @og.rev 8.1.2.0 (2022/03/10) getMD5参照して新規作成
         *
         * @param       hashCode        ﾊｯｼｭｺｰﾄﾞ (MD5, SHA-1, SHA-256, SHA-512)
         * @param       input           変換前のFileOperationｵﾌﾞｼﾞｪｸﾄ
         *
         * @return      ﾊｯｼｭｺｰﾄﾞでﾊｯｼｭした文字列
         */
        public static String getHash( final String hashCode, final FileOperation input ) {
                String rtn = null;
                if( hashCode != null && input != null ) {
                        // 8.5.4.2 (2024/01/12) PMD 7.0.0 CloseResource 対応
                        InputStream is = null;
                        DigestInputStream dis = null;
                        try {
                                final MessageDigest md = MessageDigest.getInstance( hashCode );
                                is = input.read();
                                dis = new DigestInputStream(is, md);

                                final byte[] readBuf = new byte[1024];
                                while(dis.read(readBuf) > 0) {
                                        ;       // disを読み込んで、ダイジェスト情報を更新                // 8.5.4.2 (2024/01/12) 空行を明示する方法  //NOPMD
                                }

                                // ダイジェスト情報を取得
                                final byte[] out = md.digest();
                                rtn = byte2hexa( out );
                        }
                        catch( NoSuchAlgorithmException ex ) {
                                final String errMsg = "MessageDigestで失敗しました。" + CR
                                                        + "ﾊｯｼｭｺｰﾄﾞ=[" + hashCode + "] , 変換前=[" + input + "]" + CR
                                                        + ex.getMessage() ;
                                throw new RuntimeException( errMsg,ex );
                        }
                        catch( IOException ex ) {
                                final String errMsg = "ﾌｧｲﾙの読み取りを失敗しました。[" + input + "]"
                                                        + ex.getMessage() ;
                                throw new RuntimeException( errMsg,ex );
                        }
                        finally {
                                Closer.ioClose(dis);
                                Closer.ioClose(is);
                        }
                }
                return rtn;
        }

        /**
         * MessageDigestにより、ｼｽﾃﾑ定数に定義されている ﾊｯｼｭｺｰﾄﾞ で
         * ﾊｯｼｭした文字に変換します。
         *
         * 連結後の文字列長は、ﾊｯｼｭｺｰﾄﾞにより異なります。
         *
         * @og.rev 8.1.2.0 (2022/03/10) getMD5参照して新規作成
         *
         * @param       hashCode        ﾊｯｼｭｺｰﾄﾞ (MD5, SHA-1, SHA-256, SHA-512)
         * @param       input           変換前のFile
         *
         * @return      ﾊｯｼｭｺｰﾄﾞでﾊｯｼｭした文字列
         */
        public static String getHash( final String hashCode, final File input ) {
                // 2019/X FileOperationクラスの場合は、クラウドストレージ対応のメソッドを実行します。 oota tmp
                if( input instanceof FileOperation ) {
                        return getHash( hashCode, (FileOperation)input );
                }

                String rtn = null;
                if( hashCode != null && input != null ) {
                        // 8.5.4.2 (2024/01/12) PMD 7.0.0 AvoidFileStream 対応
//                      FileInputStream fis     = null;         // 8.5.4.2 (2024/01/12)
//                      FileChannel             fc      = null;
//                      try {
                        // 8.5.4.2 (2024/01/12) PMD 7.0.0 AvoidFileStream 対応
                        try ( FileChannel fc = FileChannel.open( input.toPath(),READ ) ) {
                                final MessageDigest md = MessageDigest.getInstance( hashCode );
//                              fis = new FileInputStream( input );
//                              fc  = fis.getChannel();

        //                      fc  = Files.newInputStream( input.toPath() ).getChannel();
                                final ByteBuffer bb = fc.map( FileChannel.MapMode.READ_ONLY , 0L , fc.size() );
                                md.update( bb );
                                final byte[] out = md.digest();
                                rtn = byte2hexa( out );
                        }
                        catch( final NoSuchAlgorithmException ex ) {
                                final String errMsg = "MessageDigestで失敗しました。" + CR
                                                        + "ﾊｯｼｭｺｰﾄﾞ=[" + hashCode + "] , 変換前=[" + input + "]" + CR
                                                        + ex.getMessage() ;
                                throw new OgRuntimeException( errMsg,ex );
                        }
                        catch( final IOException ex ) {
                                final String errMsg = "ﾌｧｲﾙの読み取りを失敗しました。[" + input + "]"
                                                        + ex.getMessage() ;
                                throw new OgRuntimeException( errMsg,ex );
                        }
//                      finally {
//                              Closer.ioClose( fc );
//                              Closer.ioClose( fis );
//                      }
                }
                return rtn;
        }

        // 8.1.2.0 (2022/03/10) Delete
//      /**
//       * MessageDigestにより、MD5 でハッシュした文字に変換します。
//       *
//       * MD5で、１６Byteのバイトに変換されますが、ここでは、１６進数で文字列に変換しています。
//       *
//       * 変換方法は、各バイトの上位/下位を１６進文字列に変換後、連結しています。
//       * これは、Tomcat等の digest 認証(MD5使用時)と同じ変換方式です。
//       * 連結後の文字列長は、３２バイト(固定)になります。
//       *
//       * @og.rev 5.2.2.0 (2010/11/01) util.StringUtil から移動
//       *
//       * @param       input 変換前の文字列
//       *
//       * @return      MD5でハッシュした文字列。３２バイト(固定)
//       */
//      public static String getMD5( final String input ) {
//              String rtn = null;
//              if( input != null ) {
//                      try {
//                              final MessageDigest md5 = MessageDigest.getInstance( "MD5" );
//                              md5.update( input.getBytes( DEFAULT_CHARSET ) );        // 5.5.2.6 (2012/05/25) findbugs対応
//                              final byte[] out = md5.digest();
//                              rtn = byte2hexa( out );
//                      }
//                      catch( final NoSuchAlgorithmException ex ) {
//                              final String errMsg = "MessageDigestで失敗しました。[" + input + "]"
//                                                      + ex.getMessage() ;
//                              throw new OgRuntimeException( errMsg,ex );
//                      }
//              }
//              return rtn;
//      }

        // 8.1.2.0 (2022/03/10) Delete
//      /**
//       * MessageDigestにより、MD5 でハッシュした文字に変換します。
//       *
//       * MD5で、１６Byteのバイトに変換されますが、ここでは、１６進数で文字列に変換しています。
//       *
//       * 変換方法は、各バイトの上位/下位を１６進文字列に変換後、連結しています。
//       * これは、Tomcat等の digest 認証(MD5使用時)と同じ変換方式です。
//       * 連結後の文字列長は、３２バイト(固定)になります。
//       * 下記サイトを参考に作成しています。
//       * https://stackoverflow.com/questions/304268/getting-a-files-md5-checksum-in-java
//       *
//       * @og.rev 5.9.10.0 (2019/03/01) 新規追加。クラウドストレージ対応。
//       *
//       * @param       input 変換前のFileOperationオブジェクト
//       *
//       * @return      MD5でハッシュした文字列。３２バイト(固定)
//       */
//      public static String getMD5( final FileOperation input ) {
//              String rtn = null;
//              if( input != null ) {
//
//                      InputStream is = null;
//                      DigestInputStream dis = null;
//                      try {
//                              final MessageDigest md5 = MessageDigest.getInstance( "MD5" );
//                              is = input.read();
//                              dis = new DigestInputStream(is, md5);
//
//                              while(dis.read() > 0) {
//                                      ;       // disを読み込んで、ダイジェスト情報を更新
//                              }
//
//                              // ダイジェスト情報を取得
//                              final byte[] out = md5.digest();
//                              rtn = byte2hexa( out );
//                      }
//                      catch( NoSuchAlgorithmException ex ) {
//                              final String errMsg = "MessageDigestで MD5 インスタンスの作成に失敗しました。[" + input + "]"
//                                                      + ex.getMessage() ;
//                              throw new RuntimeException( errMsg,ex );
//                      }
//                      catch( IOException ex ) {
//                              final String errMsg = "ファイルの読み取りを失敗しました。[" + input + "]"
//                                                      + ex.getMessage() ;
//                              throw new RuntimeException( errMsg,ex );
//                      }
//                      finally {
//                              Closer.ioClose(dis);
//                              Closer.ioClose(is);
//                      }
//              }
//              return rtn;
//      }

        // 8.1.2.0 (2022/03/10) Delete
//      /**
//       * MessageDigestにより、MD5 でハッシュした文字に変換します。
//       *
//       * MD5で、１６Byteのバイトに変換されますが、ここでは、１６進数で文字列に変換しています。
//       *
//       * 変換方法は、各バイトの上位/下位を１６進文字列に変換後、連結しています。
//       * これは、Tomcat等の digest 認証(MD5使用時)と同じ変換方式です。
//       * 連結後の文字列長は、３２バイト(固定)になります。
//       *
//       * @og.rev 5.7.2.1 (2014/01/17) Exceptionをまとめます。
//       * @og.rev 5.9.10.0 (2019/03/01) クラウドストレージ対応を追加
//       *
//       * @param       input 変換前のFile
//       *
//       * @return      MD5でハッシュした文字列。３２バイト(固定)
//       */
//      public static String getMD5( final File input ) {
//              // 2019/X FileOperationクラスの場合は、クラウドストレージ対応のメソッドを実行します。 oota tmp
//              if(input instanceof FileOperation) {
//                      return getMD5((FileOperation)input);
//              }
//
//              String rtn = null;
//              if( input != null ) {
//                      FileInputStream fis     = null;
//                      FileChannel             fc      = null;
//                      try {
//                              final MessageDigest md5 = MessageDigest.getInstance( "MD5" );
//                              fis = new FileInputStream( input );
//                              fc  =fis.getChannel();
//                              final ByteBuffer bb = fc.map( FileChannel.MapMode.READ_ONLY , 0L , fc.size() );
//                              md5.update( bb );
//                              final byte[] out = md5.digest();
//                              rtn = byte2hexa( out );
//                      }
//                      catch( final NoSuchAlgorithmException ex ) {
//                              final String errMsg = "MessageDigestで MD5 インスタンスの作成に失敗しました。[" + input + "]"
//                                                      + ex.getMessage() ;
//                              throw new OgRuntimeException( errMsg,ex );
//                      }
//                      catch( final IOException ex ) {
//                              final String errMsg = "ファイルの読み取りを失敗しました。[" + input + "]"
//                                                      + ex.getMessage() ;
//                              throw new OgRuntimeException( errMsg,ex );
//                      }
//                      finally {
//                              Closer.ioClose( fc );
//                              Closer.ioClose( fis );
//                      }
//              }
//              return rtn;
//      }

//      /**
//       * MessageDigestにより、SHA1 でハッシュした文字に変換します。
//       *
//       * １６進数で文字列に変換しています。
//       *
//       * 変換方法は、各バイトの上位/下位を１６進文字列に変換後、連結しています。
//       * これは、Tomcat等の digest 認証と同じ変換方式です。
//       *
//       * @og.rev 5.9.27.1 (2010/12/08) 新規作成
//       *
//       * @param       input 変換前の文字列
//       *
//       * @return      SHA1でハッシュした文字列。３２バイト(固定)
//       */
//      public static String getSHA1( final String input ) {
//              String rtn = null;
//              if( input != null ) {
//                      try {
//                              final MessageDigest sha1 = MessageDigest.getInstance("SHA-1");
//                              sha1.update( input.getBytes( DEFAULT_CHARSET ) );
//                              final byte[] out = sha1.digest();
//                              rtn = byte2hexa( out );
//                      }
//                      catch( final NoSuchAlgorithmException ex ) {
//                              final String errMsg = "MessageDigestで失敗しました。[" + input + "]"
//                                                                              + ex.getMessage() ;
//                              throw new RuntimeException( errMsg,ex );
//                      }
//              }
//              return rtn;
//      }

        // 8.1.2.0 (2022/03/10) Delete
//      /**
//       * MessageDigestにより、SHA-512 でハッシュした文字に変換します。
//       *
//       * １６進数で文字列に変換しています。
//       *
//       * 変換方法は、各バイトの上位/下位を１６進文字列に変換後、連結しています。
//       * これは、Tomcat等の digest 認証と同じ変換方式です。
//       *
//       * @og.rev 5.10.10.2 (2019/04/12) 新規作成
//       *
//       * @param       input 変換前の文字列
//       *
//       * @return      SHA-512でハッシュした文字列 128バイト
//       */
//      public static String getSHA512( final String input ) {
//              String rtn = null;
//              if( input != null ) {
//                      try {
//                              final MessageDigest sha1 = MessageDigest.getInstance("SHA-512");
//                              sha1.update( input.getBytes( DEFAULT_CHARSET ) );
//                              final byte[] out = sha1.digest();
//                              rtn = byte2hexa( out );
//                      }
//                      catch( final NoSuchAlgorithmException ex ) {
//                              final String errMsg = "MessageDigestで失敗しました。[" + input + "]"
//                                                      + ex.getMessage() ;
//                              throw new RuntimeException( errMsg,ex );
//                      }
//              }
//              return rtn;
//      }

        /**
         * 暗号化のテストを行う為のメインメソッド
         *
         * java HybsCryptography KEY TEXT で起動します。
         *   KEY  : 秘密鍵(8 の倍数 (32 以上 448 以下)文字)
         *   TEXT : 変換する文字列
         *
         * @og.rev 5.2.2.0 (2010/11/01) 循環参照の解消(LogWriter 削除)
         *
         * @param       args    引数配列
         */
        public static void main( final String[] args ) {
                if( args.length != 2 ) {
                        System.out.println( "java HybsCryptography KEY TEXT" );
                        System.out.println( "  KEY  : 秘密鍵(8 の倍数 (32 以上 448 以下)文字)" );
                        System.out.println( "  TEXT : 変換する文字列" );
                        return;
                }

                final HybsCryptography cript = new HybsCryptography( args[0] );

                System.out.println( "IN   TEXT : " + args[1] );

                final String hexa = cript.encrypt( args[1] );
                System.out.println( "HEXA TEXT : " + hexa );

                final String data = cript.decrypt( hexa );
                System.out.println( "OUT  DATA : " + data );
        }
}