学习中...
C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace LiveMGT
{
public partial class Main : Form
{
private readonly string AppID = "703093033";
private readonly string AppKey = "e2470a332d21d641298136c2754331aa";
private readonly HttpHelper HTTP;
public Main()
{
InitializeComponent();
string PuKey = File.ReadAllText(@".\Config\PuKey.xml");
INIHelper INIFile = new INIHelper();
string Url = INIFile.Read("Server", "Url", "Null", @".\Config\Client.ini");
HTTP = new HttpHelper(AppID, AppKey, PuKey, Url);
}
private void button5_Click(object sender, EventArgs e)
{
HTTP.POST(textBox1.Text,out string reStr,out string errStr);
textBox2.Text = errStr;
textBox3.Text = reStr;
}
private void Main_Load(object sender, EventArgs e)
{
}
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using zlib;
namespace LiveMGT
{
class HttpHelper
{
private readonly string AppID;
private readonly string AppKey;
private readonly string PuKey;
private readonly string Url;
private string PHPSESSID;
#region 初始化
/// <summary>
/// 初始化
/// </summary>
public HttpHelper(string _AppID, string _AppKey, string _PuKey, string _Url)
{
AppID = _AppID;
AppKey = _AppKey;
PuKey = _PuKey;
Url = _Url;
PHPSESSID = "";
}
#endregion
#region HTTP POST
/// <summary>
/// HTTP POST
/// </summary>
/// <param name="dataStr">需要提交的字符串</param>
/// <param name="resultStr">提交后网页返回的JSON字符串</param>
/// <param name="errStr">如果提交失败返回错误内容</param>
/// <returns>成功返回true，失败返回false</returns>
public bool POST(string dataStr,out string resultStr,out string errStr)
{
resultStr = "";
errStr = "";
if (dataStr == string.Empty || dataStr == "")
{
errStr = "request_data_err";
return false;
}
try
{
string NumRan = RanNum(); //请求随机
string TimeRnd = GetTimeStamp(true); //请求时间
string KeyRnd = MD5(AppID + TimeRnd + NumRan + AppKey); //请求密钥
KeyRnd = HmacMD5(KeyRnd, AppKey); //请求密钥
string RSARnd = RSAENC(PuKey, KeyRnd); //公钥加密
RSARnd = StrToHex(RSARnd); //公钥加密
if (RSARnd == "")
{
errStr = "request_rsa_err";
return false;
}
//-----------------------------------------------------------------------------
int dataLen = dataStr.Length; //数据长度
dataStr = Compress(dataStr); //数据压缩
string postStr = RC4ENC(dataStr, KeyRnd); //加密数据
byte[] sendData = Encoding.UTF8.GetBytes(postStr); //发送数据
string cookieStr = PHPSESSID + ";appid=" + AppID + ";time=" + TimeRnd + ";rand=" + NumRan + ";length=" + dataLen + ";key=" + RSARnd;
//-----------------------------------------------------------------------------
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
request.Method = "POST";
request.ContentType = "application/x-www-form-urlencoded; charset=UTF-8";
request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36";
request.Timeout = 10000;
request.KeepAlive = false;
request.Headers.Add("Cookie", cookieStr);
request.ContentLength = sendData.Length;
Stream newStream = request.GetRequestStream();
newStream.Write(sendData, 0, sendData.Length);
newStream.Close();
HttpWebResponse myResponse = (HttpWebResponse)request.GetResponse();
StreamReader reader = new StreamReader(myResponse.GetResponseStream(), Encoding.UTF8);
string content = reader.ReadToEnd();
reader.Close();
reader.Dispose();
cookieStr = myResponse.Headers.Get("Set-Cookie");
resultStr = content;//不管是否成功都返回
//-----------------------------------------------------------------------------
if (PHPSESSID == "")
{
PHPSESSID = MidStrEx(cookieStr, "PHPSESSID=", ";");
if (PHPSESSID == string.Empty || PHPSESSID == "")
{
errStr = "response_phpsessid_err";
return false;
}
PHPSESSID = "PHPSESSID=" + PHPSESSID;
}
string _appid = MidStrEx(cookieStr, "appid=", ";");
if (_appid == string.Empty || _appid == "" || _appid != AppID)
{
errStr = "response_appid_err";
return false;
}
//-----------------------------------------------------------------------------
NumRan = MidStrEx(cookieStr, "rand=", ";"); //请求随机
TimeRnd = MidStrEx(cookieStr, "time=", ";"); //请求时间
RSARnd = MidStrEx(cookieStr, "key=", ";"); //公钥加密
dataLen = int.Parse(MidStrEx(cookieStr, "length=", ";")); //数据长度
if (NumRan == string.Empty || NumRan == "" || TimeRnd == string.Empty || TimeRnd == "" || RSARnd == string.Empty || RSARnd == "" || dataLen <= 0)
{
errStr = "response_cooikes_err";
return false;
}
KeyRnd = MD5(AppID + TimeRnd + NumRan + AppKey); //请求密钥
KeyRnd = HmacMD5(KeyRnd, AppKey); //请求密钥
RSARnd = HexToStr(RSARnd); //公钥加密
//-----------------------------------------------------------------------------
if (RSACheck(content, RSARnd, PuKey) == false)
{
errStr = "response_check_err";
return false;
}
content = RC4DEC(content, KeyRnd);
if (content == string.Empty || content == "")
{
errStr = "response_rc4dec_err";
return false;
}
content = UCompress(content, dataLen);
if (content == string.Empty || content == "")
{
errStr = "response_ucompress_err";
return false;
}
resultStr = content;
return true;
}
catch
{
return false;
}
}
#endregion
#region 取随机数
/// <summary>
/// 取随机数
/// </summary>
/// <returns></returns>
private static string RanNum()
{
try
{
Random rnd = new Random();
string num = rnd.Next(11111111, 88888888).ToString();
return num;
}
catch
{
return "";
}
}
#endregion
#region 取字符串中间
/// <summary>
/// 取字符串中间
/// </summary>
/// <param name="sourse">需要截取的字符串</param>
/// <param name="startstr">字符串前面</param>
/// <param name="endstr">字符串后面</param>
/// <returns>返回截取后字符串</returns>
private static string MidStrEx(string sourse, string startstr, string endstr)
{
try
{
string result = "";
int startindex, endindex;
startindex = sourse.IndexOf(startstr);
if (startindex == -1)
return result;
string tmpstr = sourse.Substring(startindex + startstr.Length);
endindex = tmpstr.IndexOf(endstr);
if (endindex == -1)
return result;
result = tmpstr.Remove(endindex);
return result;
}
catch
{
return "";
}
}
#endregion
#region 数据解压
/// <summary>
/// 数据解压
/// </summary>
/// <param name="strSource">需要解压的字符串</param>
/// <param name="sLen">字符串未压缩之前的长度</param>
/// <returns>返回解压后字符串</returns>
private static string UCompress(string strSource,int sLen)
{
try
{
int data;
int stopByte = -1;
byte[] Buffer = Convert.FromBase64String(strSource); // 解base64
MemoryStream intms = new MemoryStream(Buffer);
ZInputStream inZStream = new ZInputStream(intms);
byte[] inByteList = new byte[sLen];
int i = 0;
while (stopByte != (data = inZStream.Read()))
{
inByteList[i] = (byte)data;
i++;
}
inZStream.Close();
return Encoding.UTF8.GetString(inByteList, 0, inByteList.Length);
}
catch
{
return "";
}
}
#endregion
#region 数据压缩
/// <summary>
/// 数据压缩
/// </summary>
/// <param name="Source">需要压缩的字符串</param>
/// <returns>压缩后字符串</returns>
private static string Compress(string Source)
{
try
{
byte[] byteData = Encoding.UTF8.GetBytes(Source);
MemoryStream ms = new MemoryStream();
Stream s = new ZOutputStream(ms, 9);
s.Write(byteData, 0, byteData.Length);
s.Close();
byte[] compressData = (byte[])ms.ToArray();
ms.Flush();
ms.Close();
return Convert.ToBase64String(compressData);
}
catch
{
return "";
}
}
#endregion
#region 获取当前时间戳
/// <summary>
/// 获取当前时间戳
/// </summary>
/// <param name="bflag">为真时获取10位时间戳,为假时获取13位时间戳.bool bflag = true</param>
/// <returns>返回时间戳字符串</returns>
private static string GetTimeStamp(bool bflag)
{
try
{
TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
if (bflag)
return Convert.ToInt64(ts.TotalSeconds).ToString();
else
return Convert.ToInt64(ts.TotalMilliseconds).ToString();
}
catch
{
return "";
}
}
#endregion
#region 用MD5加密字符串
/// <summary>
/// 用MD5加密字符串
/// </summary>
/// <param name="password">待加密的字符串</param>
/// <returns>返回的加密后的字符串</returns>
private static string MD5(string password)
{
try
{
MD5CryptoServiceProvider md5Hasher = new MD5CryptoServiceProvider();
byte[] hashedDataBytes;
hashedDataBytes = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(password));
StringBuilder tmp = new StringBuilder();
md5Hasher.Clear();
md5Hasher.Dispose();
foreach (byte i in hashedDataBytes)
{
tmp.Append(i.ToString("x2"));
}
return tmp.ToString();//默认情况
}
catch
{
return "";
}
}
#endregion
#region HmacMD5加密
/// <summary>
/// HmacMD5加密
/// </summary>
/// <param name="source">需要加密的字符串</param>
/// <param name="keyStr">用于加密的密钥</param>
/// <returns>加密后的字符串</returns>
private static string HmacMD5(string source, string keyStr)
{
try
{
HMACMD5 provider = new HMACMD5(Encoding.UTF8.GetBytes(keyStr));
byte[] hashedPassword = provider.ComputeHash(Encoding.UTF8.GetBytes(source));
StringBuilder displayString = new StringBuilder();
for (int i = 0; i < hashedPassword.Length; i++)
{
displayString.Append(hashedPassword[i].ToString("X2"));
}
provider.Clear();
provider.Dispose();
return displayString.ToString().ToLower();//转换到小写
}
catch
{
return "";
}
}
#endregion
#region RC4加密
/// <summary>
/// RC4加密
/// </summary>
/// <param name="source">需要加密的字符串</param>
/// <param name="keyStr">用于加密的密钥</param>
/// <returns>返回加密后的字符串</returns>
private static string RC4ENC(string source, string keyStr)
{
try
{
byte[] contents = Encoding.UTF8.GetBytes(source);
return Convert.ToBase64String(RC4(contents, keyStr));//转为base64编码
}
catch
{
return "";
}
}
#endregion
#region RC4解密
/// <summary>
/// RC4解密
/// </summary>
/// <param name="source">需要加密的字符串</param>
/// <param name="keyStr">用于加密的密钥</param>
/// <returns>返回解密后的字符串</returns>
private static string RC4DEC(string source, string keyStr)
{
try
{
byte[] data = Convert.FromBase64String(source);//base64编码还原
byte[] str = RC4(data, keyStr);
return Encoding.UTF8.GetString(str);
}
catch
{
return "";
}
}
#endregion
#region RC4加密解密
/// <summary>
/// RC4加密解密
/// </summary>
/// <param name="source">需要加密的字符串</param>
/// <param name="keyStr">用于加密的密钥</param>
/// <returns>加密后的字节集</returns>
private static byte[] RC4(byte[] contents, string keyStr)
{
byte[] results = new byte[contents.Length];
byte[] pwds = Encoding.UTF8.GetBytes(keyStr);
byte[] key = new byte[256];
byte[] box = new byte[256];
for (int i = 0; i < 256; i++)
{
key[i] = pwds[i % pwds.Length];
box[i] = (byte)i;
}
for (int j = 0, i = 0; i < 256; i++)
{
j = (j + box[i] + key[i]) % 256;
byte tmp = box[i];
box[i] = box[j];
box[j] = tmp;
}
for (int a = 0, j = 0, i = 0; i < contents.Length; i++)
{
a = (a + 1) % 256;
j = (j + box[a]) % 256;
byte tmp = box[a];
box[a] = box[j];
box[j] = tmp;
byte k = box[((box[a] + box[j]) % 256)];
results[i] = (byte)(contents[i] ^ k);
}
return results;
}
#endregion
#region 字符串到十六进制
/// <summary>
/// 字符串到十六进制
/// </summary>
/// <param name="source">需要转十六进制的字符串</param>
/// <returns>返回编好后的十六进制字符串</returns>
private static string StrToHex(string source)
{
try
{
string result = string.Empty;
byte[] arrByte = Encoding.UTF8.GetBytes(source);
for (int i = 0; i < arrByte.Length; i++)
{
result += Convert.ToString(arrByte[i], 16);
}
return result.ToUpper();
}
catch
{
return "";
}
}
#endregion
#region 十六进制到字符串
/// <summary>
/// 十六进制到字符串
/// </summary>
/// <param name="hex">需要解码到字符串的十六进制文本</param>
/// <returns>返回解码后的十六进制字符串</returns>
private static string HexToStr(string hex)
{
try
{
byte[] arrByte = new byte[hex.Length / 2];
int index = 0;
for (int i = 0; i < hex.Length; i += 2)
{
arrByte[index++] = Convert.ToByte(hex.Substring(i, 2), 16);
}
return Encoding.UTF8.GetString(arrByte);
}
catch
{
return "";
}
}
#endregion
#region RSA公钥加密
/// <summary>
/// RSA公钥加密
/// </summary>
/// <param name="xmlPublicKey">公钥XML文件</param>
/// <param name="content">需要加密的内容</param>
/// <returns>返回加密后字符串</returns>
private static string RSAENC(string xmlPublicKey, string content)
{
try
{
string encryptedContent = string.Empty;
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
rsa.FromXmlString(xmlPublicKey);
byte[] encryptedData = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
encryptedContent = Convert.ToBase64String(encryptedData);
}
return encryptedContent;
}
catch
{
return "";
}
}
#endregion
#region RSA验证
/// <summary>
///
/// </summary>
/// <param name="str">需要验证的文本</param>
/// <param name="sign">私钥签名的字符串</param>
/// <param name="str_publicKey">公钥XML文件</param>
/// <returns>返回验证结果</returns>
private static bool RSACheck(string str, string sign, string str_publicKey)
{
try
{
byte[] SignedData = Convert.FromBase64String(sign);
ASCIIEncoding ByteConverter = new ASCIIEncoding();
byte[] DataToVerify = ByteConverter.GetBytes(str);
RSACryptoServiceProvider RSAalg = new RSACryptoServiceProvider();
RSAalg.FromXmlString(str_publicKey);
bool result = RSAalg.VerifyData(DataToVerify, new SHA1CryptoServiceProvider(), SignedData);
RSAalg.Clear();
RSAalg.Dispose();
return result;
}
catch
{
return false;
}
}
#endregion
}
}
PHP
<?php
//-----------------------APP基础配置----------------------------
define("app_id", "703093033");
define("app_key", "e2470a332d21d641298136c2754331aa");
//-----------------------RSA密钥配置----------------------------
define("private_key", "-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAy4RN2yLtquuGD77wX0IaWpfgbN70G5+dlhsfowKJy7oxP+cC
PKINXUkF5rSdTveGUlZDOtLYJghOD7biloJdW5+6mglGguVIC7430gdW/btT3Yul
3+IZa6Zj6SdGsmyOE4WPbjS6q8aUBmOdHf7dVYfbRVk9jZnBCEx/64S8kQI4Jz8o
2tV6rKvKkyTn///dBKDKSPWYtOG2bq7G1XwYrf8PLL0Ek7lRHX5w7JVWovDhKsGq
Xoho9CxM2sZRCSMeZpdBU9+xxFjNGl5NQHyWJefKzVdXFT9sF/UZGu1UXRuiCQyf
1LJvweIwyBo1ctcuJdRMNrZxoBCUYile2LiTQQIDAQABAoIBAHrt5aEyDeEp9oZY
TRUc9pI2HudkHIr69NMQeyGZjOY0Bz+UJ/O75tqsGxZpjoN+W/IsDNvhM5J1fcFc
NK24/O81Ih+c7qxuFgCR22HP8Sm+F0BA8+axya0Oilbw1HE9xOvhxutIimDrx8m8
LdFKeyMIttfCub1oXALJQpNeUBA99LBtVCV4aJdLTZh82XNCaKg0w7t+KLz8i98K
JAMvuYg6A4Vv0zlG1CbTvykOJ0CyKMw3BlQMRm7U+6K8g3S5pHpnCQJURssd58hr
uJAvDP4T1oEXEsqF135pQh2oK7qufHRgRWTSihHUXIx/uFXs52BvPIt7meJq6PBG
ONA28ykCgYEA8n+HrygKpCEHhyrtwtiV2zwBnEcQz10TVtp7vmWYm3ECpLobwyJI
sSiq0fUMPga1bDYxtxRXkOI+bj3e7jBPcmhvlQvvWeXBUhtq8J1wQzYlg+HI4+K/
oUfT3hY6Vp/4eVLA9ro3NPPwXDRyjS/UsKtiMb1PInRcER/4AFdkLBsCgYEA1tkm
Woxp+dgK7TRIdsdk3B3E6H/HmzADZYtJr7BxePhp4HJtXFakAHiY90mAeu2TvyeM
ewYXEE/wGqdae7yVydgHchHd8auGOIoimlhRmmOM6Hvmr4KvYDXgK3dHSCrueNhB
U/CWyTeFYKHNhbEbkswvDESohqGKWjzUqkTaO9MCgYBfvP3Cp1pcJjYkpUwtSvkP
DwfLvTrjw2lpNuT37IBtjhZvFpLzXUu5tcaLEeX9bwSdbl/+WeegadIgEAk9nJEh
KB41h/q9UTobwntb96xkvLHe+XsojVL+x67b1Ya+wHWG4KcSQb6eB1jz7jjziNi9
z0v7OzRM9AeNM0PkTpxb1QKBgBdUBMIYNPmX57fR0Xx0MhNkeBj2punG0NeZxCp7
cha8gmKIii9YiP40Ggffxz+RxFUhKjPBeYef5mY+faip1WnRNx2/quWuxigld5Ri
upmU7ZvguC+edQRxVSHjFa5UWwhsEsvWd8jpamYPq400qdXKreEbI2Fa8PbTXBQQ
3dFZAoGAVPeYH7IWLiMUsRHY5r/oEZjAjHj1QadARtgAX8NCopRbplsJHadXqg5y
UiPRRDn5XFROf0PqgDrVUN2vLkKrQQIlJPvruQNDELyXkwQWPVbNA1Q2aLIi5GWt
OzUJVxNNHxo+//GLZD09ZKdDiBUtYGqFU3cE1+CSA6L5IRVqTFo=
-----END RSA PRIVATE KEY-----");
//-----------------------校验函数定义----------------------------
//十六进制转字符串
function hexToStr($hex){
$string="";
for($i=0;$i<strlen($hex)-1;$i+=2)
$string.=chr(hexdec($hex[$i].$hex[$i+1]));
return $string;
}
//字符串转十六进制
function strToHex($string){
$hex="";
for($i=0;$i<strlen($string);$i++)
$hex.=dechex(ord($string[$i]));
$hex=strtoupper($hex);
return $hex;
}
//私钥解密由加密函数加密后的base64编码
function rsadec($data){
$pi_key = openssl_pkey_get_private(private_key);
$data = base64_decode($data);
$decrypted = "";
$isOkay = openssl_private_decrypt($data, $decrypted, $pi_key);
if(!$isOkay){
return false;
}
return $decrypted;
}
//RSA签名
function getSign($signString){
$privKeyId = openssl_pkey_get_private(private_key);
$signature = '';
openssl_sign($signString, $signature, $privKeyId);
openssl_free_key($privKeyId);
return base64_encode($signature);
}
//HMAC_MD5加密
function hmac($data, $key){
if (function_exists('hash_hmac')) {
return hash_hmac('md5', $data, $key);
}
$key = (strlen($key) > 64) ? pack('H32', 'md5') : str_pad($key, 64, chr(0));
$ipad = substr($key,0, 64) ^ str_repeat(chr(0x36), 64);
$opad = substr($key,0, 64) ^ str_repeat(chr(0x5C), 64);
return md5($opad.pack('H32', md5($ipad.$data)));
}
//rc4加密并返回base64编码
function rc4enc($pwd, $data){
return base64_encode(rc4($pwd, $data));
}
//解密由加密函数加密后的base64编码
function rc4dec($pwd, $data){
$data = base64_decode($data);
return rc4($pwd, $data);
}
//RC4加密解密
function rc4($pwd, $data){
$cipher = "";
$key[] = "";
$box[] = "";
$pwd_length = strlen($pwd);
$data_length = strlen($data);
for ($i = 0; $i < 256; $i++) {
$key[$i] = ord($pwd[$i % $pwd_length]);
$box[$i] = $i;
}
for ($j = $i = 0; $i < 256; $i++) {
$j = ($j + $box[$i] + $key[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for ($a = $j = $i = 0; $i < $data_length; $i++) {
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$k = $box[(($box[$a] + $box[$j]) % 256)];
$cipher .= chr(ord($data[$i]) ^ $k);
}
return $cipher;
}
//回复验证信息
function sendMsg($msg){
$time = time();
$rand = rand(11111111, 88888888);
$md5 = md5(app_id.$time.$rand.app_key);
$md5 = hmac($md5,app_key);
setcookie("appid",app_id,time() + 300); //5分钟内有效
setcookie("time",$time,time() + 300); //5分钟内有效
setcookie("rand",$rand,time() + 300); //5分钟内有效
//----------------------------------------------
$len = strlen($msg); //长度
setcookie("length",$len,time() + 300); //5分钟内有效
//----------------------------------------------
$str = base64_encode(gzcompress($msg, 9)); //压缩
$str = rc4enc($md5,$str); //加密
$key = getSign($str); //签名
$key = strToHex($key);
setcookie("key",$key,time() + 300); //5分钟内有效
//----------------------------------------------
echo $str;
exit();
}
//-----------------------取出_COOKIE----------------------------
$appid = $_COOKIE["appid"]; //请求标识
$time = $_COOKIE["time"]; //请求时间
$rand = $_COOKIE["rand"]; //请求随机
$length = $_COOKIE["length"]; //数据长度
$key = $_COOKIE["key"]; //公钥加密
$now = time() - 1; //现行时间戳(减1防止提交太快造成负数)
//判断参数合法性
if($appid == "" or $time =="" or $rand =="" or $length =="" or $key ==""){
echo "COOKIE_ERR";
exit();
}
//判断appid
if($appid != app_id){
echo "AppID_ERR";
exit();
}
//请求间隔
$interval = $time - $now;
//必须是10秒之内的请求
if($interval < 0 or $interval > 10){
echo "interval_err";
exit();
}
//判断随机数
if($rand <= 0){
echo "rand_err";
exit();
}
//还原加密串
$key = hexToStr($key);
if($key == ""){
echo "key_err";
exit();
}
//解密加密串
$key = rsadec($key);
if($key == ""){
echo "rsa_err";
exit();
}
//检测公钥加密
$md5 = md5($appid.$time.$rand.app_key);
$md5 = hmac($md5,app_key);
if($key != $md5){
echo "rc4_err";
exit();
}
//取请求数据
$post = file_get_contents('php://input');
if($post == ""){
echo "post_err";
exit();
}
//解密数据
$post = rc4dec($key,$post);
if($post == ""){
echo "rc4dec_err";
exit();
}
//解压数据
$post = gzuncompress(base64_decode($post));
if($post == ""){
echo "gzuncompress_err";
exit();
}
echo sendMsg($post);
?>