procedure EncryptString
     (vSource                       in  varchar2,                    -- Входная строка
      vResultCrypt                  out varchar2)                    -- Зашифрованная строка
   is
   begin
      vResultCrypt := utl_raw.cast_to_varchar2(
        utl_encode.base64_encode(
           DBMS_CRYPTO.ENCRYPT
              (
                 UTL_RAW.CAST_TO_RAW(CONVERT(vSource,'AL32UTF8')),
                 DBMS_CRYPTO.ENCRYPT_AES256 + DBMS_CRYPTO.CHAIN_CBC + DBMS_CRYPTO.PAD_PKCS5,
                 KEY_RAW
              )));
   end;

    public static class Cryptograph
    {
        #region Encrypt

        public static byte[] Encrypt(byte[] data, string password)
        {
            return Encrypt(data, new PasswordDeriveBytes(password, null).GetBytes(32));
        }

        public static byte[] Encrypt(byte[] data, byte[] key)
        {
            switch (key.Length)
            {
                case 16:
                case 24:
                case 32: break;
                default:
                    throw new ArgumentException("Key must be 16, 24 or 32 bytes in length");
            }

            using (SymmetricAlgorithm algorithm = Rijndael.Create())
            using (ICryptoTransform encryptor = algorithm.CreateEncryptor(key, new byte[16]))
            using (MemoryStream m = new MemoryStream())
            using (CryptoStream c = new CryptoStream(m, encryptor, CryptoStreamMode.Write))
            {
                c.Write(data, 0, data.Length);
                c.FlushFinalBlock();

                return m.ToArray();
            }
        }

        public static string Encrypt(string data, string password)
        {
            return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(data), password));
        }

        public static string Encrypt(string data, byte[] key)
        {
            return Convert.ToBase64String(Encrypt(Encoding.UTF8.GetBytes(data), key));
        }

        #endregion

        #region Decrypt

        static public byte[] Decrypt(byte[] data, string password)
        {
            return Decrypt(data, new PasswordDeriveBytes(password, null).GetBytes(32));
        }

        public static byte[] Decrypt(byte[] data, byte[] key)
        {
            switch (key.Length)
            {
                case 16:
                case 24:
                case 32: break;
                default:
                    throw new ArgumentException("Key must be 16, 24 or 32 bytes in length");
            }

            using (SymmetricAlgorithm algorithm = Rijndael.Create())
            using (ICryptoTransform decryptor = algorithm.CreateDecryptor(key, new byte[16]))
            using (MemoryStream m = new MemoryStream(data))
            using (CryptoStream s = new CryptoStream(m, decryptor, CryptoStreamMode.Read))
            using (BinaryReader r = new BinaryReader(s))
                return r.ReadBytes((int) r.BaseStream.Length);
        }

        public static string DecryptToString(byte[] data, byte[] key)
        {
            switch (key.Length)
            {
                case 16:
                case 24:
                case 32: break;
                default:
                    throw new ArgumentException("Key must be 16, 24 or 32 bytes in length");
            }

            using (SymmetricAlgorithm algorithm = Rijndael.Create())
            using (ICryptoTransform decryptor = algorithm.CreateDecryptor(key, new byte[16]))
            using (MemoryStream m = new MemoryStream(data))
            using (CryptoStream s = new CryptoStream(m, decryptor, CryptoStreamMode.Read))
            using (StreamReader r = new StreamReader(s))
                return r.ReadToEnd();
        }

        public static string DecryptToString(string data, string password)
        {
            return DecryptToString(Convert.FromBase64String(data), new PasswordDeriveBytes(password, null).GetBytes(32));
        }

        public static string DecryptToString(string data, byte[] key)
        {
            return DecryptToString(Convert.FromBase64String(data), key);
        }

        #endregion
    }

UTL_RAW.CAST_TO_RAW(CONVERT(vSource,'AL32UTF8')),