방실이의 홈페이지

        /// <summary>
        /// 기본 키 사이즈는 128비트
        /// </summary>
        public AriaProvider()
        {
            this.keySize = 128;
            this.aria = new AriaAlgorithm(this.keySize);
        }

        /// <summary>
        /// 기본 키사이즈는 128
        /// </summary>
        /// <param name="keySize">128, 192, 256만 지원</param>
        public AriaProvider(int keySize)
        {
            this.keySize = keySize;
            this.aria = new AriaAlgorithm(this.keySize);
        }

        /// <summary>
        /// 암복호화에 이용할 마스터 키
        /// 키사이즈에 따라 달라짐(키사이즈:마스터키.Length)
        /// (128:16, 192:24, 256:32)
        /// </summary>
        public byte[] MasterKey
        {
            get { return masterKey; }
            set
            {
                switch (this.keySize)
                {
                    case 128:
                        if (value.Length != 16)
                        {
                            throw new ArgumentException("MasterKey's Length : " + value.Length.ToString());
                        }
                        else
                        {
                            this.masterKey = value;
                        }
                        break;
                    case 192:
                        if (value.Length != 24)
                        {
                            throw new ArgumentException("MasterKey's Length : " + value.Length.ToString());
                        }
                        else
                        {
                            this.masterKey = value;
                        }
                        break;
                    case 256:
                        if (value.Length != 32)
                        {
                            throw new ArgumentException("MasterKey's Length : " + value.Length.ToString());
                        }
                        else
                        {
                            this.masterKey = value;
                        }
                        break;
                }
            }
        }

        /// <summary>
        /// 마스터키의 기본값을 정의 한다.
        /// </summary>
        private void SetDefaultMasterKey()
        {
            if (this.masterKey == null)
            {
                int length = (this.keySize == 128) ? 16 : ((this.keySize == 192) ? 24 : 32);
                this.masterKey = new byte[length];
                for (int i = 0; i < length; i++)
                {
                    this.masterKey[i] = (byte)i;
                }
            }
        }

    //선언
    internal class AriaKey
    {
        internal static byte[] PublicKey = { 42, 52, 64, 1, 0, 135, 123, 75, 34, 12, 43, 74, 36, 28, 92, 16 };
    }

            //사용
            AriaProvider aria = new AriaProvider();
            aria.MasterKey = AriaKey.PublicKey;

        /// <summary>
        /// 문자열을 받아 암호화된 문자열을 반환한다.
        /// </summary>
        /// <param name="inputText">암호화할 문자열입니다.</param>
        /// <returns>암호화된 문자열입니다.</returns>
        public string EncryptToString(string inputString)
        {
            if (String.IsNullOrEmpty(inputString))
            {
                return inputString;
            }
            else
            {
                this.Encrypt(inputString);

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < this.cipherTextBlock.Length; i++)
                {
                    sb.Append(BitConverter.ToString(this.cipherTextBlock[i]).Replace("-", ""));
                }
                return sb.ToString();
            }
        }

        /// <summary>
        /// 문자열을 받아 암호화된 byte[]을 반환한다.
        /// </summary>
        /// <param name="inputText">암호화할 문자열입니다.</param>
        /// <returns>암호화된 byte[]입니다.</returns>
        public byte[] EncryptToByteArray(string inputString)
        {
            if (String.IsNullOrEmpty(inputString))
            {
                return null;
            }
            else
            {
                this.Encrypt(inputString);

                byte[] retValue = new byte[this.cipherTextBlock.Length * 16];
                for (int i = 0, j = 0; i < this.cipherTextBlock.Length; i++, j += 16)
                {
                    Buffer.BlockCopy(this.cipherTextBlock[i], 0, retValue, j, 16);
                }
                return retValue;
            }

        /// <summary>
        /// 암호화된 문자열을 받아 복호화한다.
        /// </summary>
        /// <param name="inputText">암호화된 문자열입니다.</param>
        /// <returns>복호화된 문자열입니다.</returns>
        public string DecryptFromString(string inputString)
        {
            if (String.IsNullOrEmpty(inputString))
            {
                return inputString;
            }
            else
            {
                this.Decrypt(inputString);

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < this.plainTextBlock.Length; i++)
                {
                    sb.Append(Encoding.Default.GetString(this.plainTextBlock[i]));
                }
                return sb.ToString().Trim();
            }
        }

        /// <summary>
        /// 암호화된 byte[]을 받아 복호화한다.
        /// </summary>
        /// <param name="inputByteArray">암호화된 byte[]입니다.</param>
        /// <returns>복호화된 문자열입니다.</returns>
        public string DecryptFromByteArray(byte[] inputByteArray)
        {
            if (inputByteArray == null || inputByteArray.Length == 0)
            {
                return String.Empty;
            }
            else
            {
                this.Decrypt(inputByteArray);

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < this.plainTextBlock.Length; i++)
                {
                    sb.Append(Encoding.Default.GetString(this.plainTextBlock[i]));
                }
                return sb.ToString().Trim();
            }
        }

/// <summary>
/// 암호화된 문자열을 받아 복호화한다.
/// </summary>
/// <param name="inputText">암호화된 문자열입니다.</param>
/// <returns>복호화된 문자열입니다.</returns>
public string DecryptFromString(string inputString)
{
    byte[] dest = new byte[inputString.Length];
    if (String.IsNullOrEmpty(inputString))
    {
        return inputString;
    }
    else
    {
        this.Decrypt(inputString);

        for (int i = 0, j = 0; i < this.plainTextBlock.Length; i++, j += 16)
        {
            Buffer.BlockCopy(this.plainTextBlock[i], 0, dest, j, 16);
        }
        return Encoding.Default.GetString(dest);
    }
}

/// <summary>
/// 암호화된 byte[]을 받아 복호화한다.
/// </summary>
/// <param name="inputByteArray">암호화된 byte[]입니다.</param>
/// <returns>복호화된 문자열입니다.</returns>
public string DecryptFromByteArray(byte[] inputByteArray)
{
    byte[] dest = new byte[inputByteArray.Length];
    if (inputByteArray == null || inputByteArray.Length == 0)
    {
        return String.Empty;
    }
    else
    {
        this.Decrypt(inputByteArray);

        for (int i = 0, j = 0; i < this.plainTextBlock.Length; i++, j += 16)
        {
            Buffer.BlockCopy(this.plainTextBlock[i], 0, dest, j, 16);
        }
        return Encoding.Default.GetString(dest);
    }
}

        #region Constructor
        private SqlDB(){}
        public SqlDB(string connectionString)
        {
            this.connection = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings[connectionString].ToString());
        }
        #endregion

  <connectionStrings>
    <add name="con" connectionString="server=(local);uid=sa;pwd=password;database=myhome;Asynchronous Processing=true;"/>
  </connectionStrings>

            SqlDB db = new SqlDB("con");

            for (int i = 0, j = 0; i < parameters.Length; )
            {
                if (parameters[i].Direction != ParameterDirection.ReturnValue && parameters[i].Direction != ParameterDirection.Output)
                {
                    if (values[j] == null)
                    {
                        parameters[i].Value = DBNull.Value;
                        i++;
                        j++;
                    }
                    else
                    {
                        parameters[i].Value = values[j];
                        i++;
                        j++;
                    }
                }
                else
                {
                    i++;
                }
            }

        internal bool AddFile(List<BoardFileItem> fileList, Guid postId)
        {
            SqlDB db = new SqlDB(this.connectionString);
            db.BeginTransaction();
            foreach (BoardFileItem item in fileList)
            {
                SqlParameter[] param ={
                    new SqlParameter("@PostId", SqlDbType.UniqueIdentifier),
                    new SqlParameter("@RealName", SqlDbType.VarChar,128),
                    new SqlParameter("@VirtualName", SqlDbType.VarChar,32),
                    new SqlParameter("@FileSize", SqlDbType.Int),
                    new SqlParameter("@ContentType", SqlDbType.VarChar,64)
                };
                if (1 != db.ExecuteNonQuery(false, false, CommandType.StoredProcedure, "Board_AddFile", param, item.PostId, item.RealFileName, item.VirtualFileName, item.Size, item.ContentType))
                {
                    db.RollBackTransaction();
                    return false;
                }
            }
            SqlParameter[] param1 = {
                    new SqlParameter("@PostId", SqlDbType.UniqueIdentifier)
            };
            if (1 != db.ExecuteNonQuery(false, false, CommandType.StoredProcedure, "Board_FileCheck", param1, postId))
            {
                db.RollBackTransaction();
                return false;
            }
            db.CommitTransaction();
            return true;
        }