我喜欢黑夜,喜欢网络安全,孤独寂寞的黑夜里,我只需要,一包烟,一台笔记本...
更多
首  页>>工具下载>>SWebScan3.0网站目录扫描器,Java版网站目录扫描器JWebScan
SWebScan3.0网站目录扫描器,Java版网站目录扫描器JWebScan
45836 阅
7 推荐
7 评论

此程序停止维护,全新升级版本超级Web漏洞扫描器

http://www.shack2.org/article/1434992090.html


名称SWebScan,S网站扫描器

简介:基于c#编写的一个网站扫描器

功能:扫描网站关键目录,地址,为渗透前期做准备,发现网站漏洞,可扫关键目录,asp,mdb,aspx,php,jsp网站

可以随心所遇自定义目录字典。

 

程序说明:

1. 本程序开发语言c#,开发工具Microsoft Visual Studio 2010,如自己需要修改源码,请下载源码包

2. Java版的需要安装oracle公司的jdk,采用NeatBeans7.2开发,需要的,自己将源码包,导入NeatBeans

下载地址:http://www.oracle.com/technetwork/java/javase/downloads/jdk6u35-downloads-1836443.html

下载地址2:http://www.xin126.cn/soft_show.asp?id=17

注:

本程序供学习C#编程使用,请勿非法使用,涉及到相关法律问题,一概与本人无关。


V2.0程序使用说明


1.关于休眠,这里是指程序在扫描中线程休息的时间,设置越小,程序扫描越快,但是使用cpu也越大,反之扫描越慢,使用cpu越小,根据自己电脑配置设置,一般默认设置就行了。

2.HEAD,GET两种请求方式,HEAD较快
3.字典文件存放在软件当前dic目录下,如需自定义字典,可以以UTF-8编码格式保存任意格式的文本文件存放在dic目录,程序会自动识别加载
4.线程数量根据网速来调整,默认建议20个线程(本人10M带宽,其实这个一般取决与你访问目标网站的响应时间),超时表示,发出一个http请求,超过这个时间就放弃请求,休眠表示发出一个请求后休息多长时间在发出请求,单位都是秒。
5.302提示-默认不提示http状态码为:404和超时0,如需提示302,请勾上
6.后缀-这里主要是为自定义字典提供,如生成目录字典后,默认不选择后缀,那就是扫目录,添加了后缀那就是扫文件,后缀配置可config.ini用记事本打开配置。
7.扫描结果里面可以双击直接在IE中打开连接,也可以单击右键打开,可以删除扫描的URL,也可以导出成文本,导出成功后存放在当前scanresult目录里。


V3.0程序使用说明

参见v2,自己慢慢实验,欢迎向我提交bug


本程序是在本人无聊之余,自己用c#语言编写的,供大家学习c#使用。

为了上字典更强大,希望大家上传共享自己的字典。

字典上传地址:http://www.shack2.org/dic/index.html



更新:V3.1版本

2014/12/27 更新,修复兼容问题,server03 xp可完美运行,扫描速度更快。

下载地址:

大字典版:/static/uploads/file/20141228/20141228022720_923.rar

小字典版:/static/uploads/file/20141228/20141228022744_842.rar



更新:

2014/4/17 更新,修复部分智能404识别,增强识别率,新增WAF过滤,点百度网盘下载更新


2014/4/4

全新 3.0版发布

支持批量域名扫描

支持智能的404识别

支持指纹识别

支持IP获取

修复2.0中跨线程调用异常,界面刷新bug,3.0中使用委托解决了

下载地址:http://pan.baidu.com/s/1dDCFbix


V3.0探测其他HTTP端口方法,只需自定义其他端口字典即可,如要批量探测内网HTTP服务,可以生成扫描IP文本。

如:

:80/
:88/
:888/
:8080/
:8081/
:8082/
:8083/
:8084/
:8085/
:8086/
:8087/
:8088/
:8089/
:8090/
:8888/
:9000/
:9001/
:9002/
:9003/
:9004/
:9005/
:9006/
:9007/
:9008/
:9009/
:9010/
:9080/



2013/9/19


    2.0正式版发布,优化程序性能,优化字典,新增导出扫描结果,添加程序检查更新设置,以后可自动检测更新。

    请下拉到下载地址下载


2013/9/9

    2.0测试版发布,此次采用TCP层的HTTP访问,提高扫描速度,自定义字典更灵活。


2012-10-9

c#版swebscan 更新到v1.1,修复一些bug,新增web信息探测功能

Java版-JWebScan发布

2012-10-27

c#版swebscan 更新到v1.2,重新分类字典,加强字典

Java版-JWebScan同步更新字典,加强字典


SWebScan V3.0




SWebScan V2.0 beta版


JWebScan-v1.0


下载说明:请右键目标另存为下载,会乱码哟,你懂的


下载地址:

-----------------Java版,运行环境,Oracle jdk1.6---------------

源码和jar包都在这里:

JWebScan-v1.0.rar



-----------------c#版,运行环境,微软.net framework 3.5-----------------


V3.0正式版 2014/04/07

    下载地址:http://pan.baidu.com/s/1dDCFbix



V2.0正式版 2013/9/19

    下载地址:/static/uploads/file/20130919/20130919165958_801.rar



V2.0测试版 2013/9/9

    下载地址:/static/uploads/file/20130909/20130909132421_407.rar


v1.0

exe执行文件下载:

swebscan_exe.rar

源码包下载:

SWebScan_code.rar


v1.1

SWebScan-v1.1.rar


v1.2

SWebScan-v1.2.rar




V3.0核心源代码

FrmMain.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Threading;
using System.Net;
using System.Text.RegularExpressions;
using My.Tools;

namespace SWebScan
{
    public partial class FrmMain : Form
    {
        public FrmMain()
        {
            InitializeComponent();
            Control.CheckForIllegalCrossThreadCalls = false;
        }

        public Listlist_domins = new List();
        public Listlist_dirs = new List();
        public ServerInfo[] serverinfos = { };
        public Listsucess_result = new List();

        public Thread th;//扫描线程
        public Thread c_th;//更新扫描数量线程
        public Listlist_th = new List();//http访问线程的集合,放这里方便控制

        public int maxThead = 10;//最大线程数,默认10个
        public int sleepTime = 0;//扫描休息时间,默认不休息
        public int timeout = 10000; //默认超时10秒
        public String weburl = "";//扫描网站
        public int status = 0;//0未启动,1正在扫描,-1正在停止扫描中
        public bool up404 = false;//智能404未启动
        public bool zwup = false;//指纹未启动
        public bool ipup = false;//获取ip信息未
        public int tmpCount = 0;//目录扫描次数启动
        public int success = 0;//扫描完成域名数
        public int scanCount = 0;//目录扫描次数
        public long usedtime = 0;//扫描完成域名数
        public String method = "HEAD";//默认HEAD扫描方式
        public String showCode = "403,200";//显示状态码
 

        //发现url数量
        public int id = 0;

        private void FrmMain_Shown(object sender, EventArgs e)
        {
            //自动检测更新
            Thread th = new Thread(new ThreadStart(checkUpdate));
            th.Start();
            //加载字典列表
            Listlist_dics = Tools.readAllDic();

            if (list_dics.Count == 0)
            {
                MessageBox.Show("没有读取到字典列表,请查看当前dic目录是否存在字典文件!");
            }
            this.cmb_dic.DataSource = list_dics;

            //select head method
            this.cmb_http_type.SelectedIndex = 0;

            this.cmb_threadCount.SelectedIndex = 14;
            this.cmb_timeout.SelectedIndex = 5;
            this.cmb_ext.SelectedIndex = 0;
            this.cmb_sleepTime.SelectedIndex = 0;

            //加载后缀配置
            String ext_config = FileTool.readFileToString("config.ini");

            try
            {
                this.cmb_ext.DataSource = ext_config.Split(',');
            }
            catch (Exception ex)
            {
                MessageBox.Show("后缀配置格式错误,请查看帮助如何配置自定义后缀!");
            }
        }
        //目录扫描
        public void scan(Object osvinfo)
        {
            ServerInfo svinfo = (ServerInfo)osvinfo;

            if (svinfo.up404)
            {

                String header = HttpTools.getHttpHeaderByTCP(this.method, svinfo.url, this.timeout, 600);
                int code = Tools.getHttpCode(header);
                int length = Tools.getLength(header);

                if (svinfo.code == 301 || svinfo.code == 302||code == 200)
                {
                  
                    if (svinfo.code==code&&length != 0 && length == svinfo.length)
                    {
                        svinfo.code = 404;
                    }
                    else
                    {
                        svinfo.code = code;
                    }
                }/*
                else if (code == 200)
                {
                   if(svinfo.code==code&&length != 0 && length == svinfo.length){
                        svinfo.code = 404;
                   }
                   else if (length < 10)
                   {
                       svinfo.code = 404;
                   }
                   else {
                       svinfo.code = code;
                   }
                }*/
                else if(code==403){
                    if (length > 512)
                    {
                        svinfo.code = 404;
                    }
                    else {
                        svinfo.code = code;
                    }
                }
                else
                {
                    svinfo.code = code;
                }
            }
            else {

                svinfo.code = Tools.getHttpCode(HttpTools.getHttpHeaderByTCP(this.method, svinfo.url, this.timeout, 15));
            }
            if (this.showCode.IndexOf(svinfo.code + "") != -1&&svinfo.code!=0)
            {
                sucess_result.Add(svinfo);
                this.Invoke(new DelegateAddItemToListView(AddItemToListView), svinfo);
            }
            //扫描成功数加一
            scanCount++;
        }
        //指纹IP扫描
        public void zwScan(Object osvinfo)
        {
            ServerInfo svinfo = (ServerInfo)osvinfo;
            if (svinfo.up404)
            {
                svinfo.url += "/aabcdsgsgshsft";
            }
            String header = HttpTools.getHttpHeaderByTCP(this.method, svinfo.url, this.timeout, 600);
            svinfo.code = Tools.getHttpCode(header);
            if (svinfo.up404) {
                svinfo.length = Tools.getLength(header); 
            }
            if (svinfo.upzw)
            {
                svinfo.server = Tools.getServerInfo(header);
                svinfo.powerBy = Tools.getPowerBy(header);
            }
            if (svinfo.upip)
            {
                svinfo.ip = Tools.getIP(svinfo.url);
            }

            if (svinfo.code != 0 && (svinfo.upip | svinfo.upzw))
            {
                this.Invoke(new DelegateAddItemToListView(AddItemToListView), svinfo);

            }

            if (svinfo.code == 0)
            {
                //响应为0,超时域名记录到日志
                FileTool.AppendLogToFile("logs/failed_domains.txt", svinfo.url);
            }
            else
            {
                //404信息按顺序放到集合
                serverinfos[svinfo.domainid]=svinfo;
            }

            //扫描成功数加一
            scanCount++;
        }

        public void clearThread()
        {
            for (int i = 0; i < list_th.Count; i++)
            {
                Thread cth = list_th[i];

                if (cth.IsAlive == false)
                {
                    list_th.Remove(cth);
                }
                Thread.Sleep(this.sleepTime);
            }
        }

        public void initThread(ServerInfo server, int type)
        {
            while (true)
            {
                clearThread();
                if (list_th.Count < this.maxThead)
                {

                    Thread th = null;
                    if (type == 1)
                    {
                        th = new Thread(new ParameterizedThreadStart(zwScan));
                    }
                    else
                    {
                        th = new Thread(new ParameterizedThreadStart(scan));
                    }
                    list_th.Add(th);
                    th.Start(server);
                    break;
                }
            }
        }
        //停止扫描
        public void stopScan()
        {
            //停止计时器
            this.timer_usedtime.Stop();
            this.btn_start.Enabled = true;
            status = -1;
            while (list_th.Count > 0)
            {
                clearThread();

                Thread.Sleep(900);
            }
            this.timer_usedtime.Stop();
            updateScanStatus();
            status = 0;
            MessageBox.Show("扫描任务完成,可以右键导出扫描结果了!");
            if (th != null)
            {

                th.Abort();
            }
        }
        delegate void DelegateAddItemToListView(ServerInfo svinfo);
        public void AddItemToListView(ServerInfo svinfo)
        {
            ListViewItem lvi = new ListViewItem(svinfo.id + "");
            lvi.SubItems.Add(svinfo.url);
            lvi.SubItems.Add(svinfo.code + "");
            lvi.SubItems.Add(svinfo.server + "");
            lvi.SubItems.Add(svinfo.powerBy + "");
            lvi.SubItems.Add(svinfo.ip + "");
            this.lvw_info.Items.Add(lvi);
        }

        public void timer_usedtime_Tick(object sender, EventArgs e)
        {
            usedtime++;
            this.Invoke(new DelegateUpdateScanStatus(updateScanStatus));

        }
        delegate void DelegateUpdateScanStatus();
        public void updateScanStatus()
        {

            this.lbl_speed.Text = (this.scanCount - this.tmpCount).ToString();
            this.tmpCount = this.scanCount;
            this.lbl_usedtime.Text = this.usedtime.ToString();
            this.lbl_c_url.Text = this.weburl;
            this.lbl_scanedCount.Text = this.success.ToString();
            this.lbl_sumScanCount.Text = this.scanCount.ToString();
            this.lbl_currenThreadCount.Text = this.list_th.Count.ToString();
            this.lbl_c_url.Text = this.weburl;

        }

        public void btn_stop_Click(object sender, EventArgs e)
        {
            if (status == 1)
            {
                status = -1;
            }
            else if (status == -1)
            {
                DialogResult dr = MessageBox.Show("正在等待线程结束后,停止任务,如果要立即停止所有线程,结束任务,点确定!", "提示", MessageBoxButtons.OKCancel);

                if (DialogResult.OK.Equals(dr))
                {
                    foreach(Thread th in list_th){
                        th.Abort();
                    }
                    list_th.Clear();
                }
            }

        }

        private void lvw_info_DoubleClick(object sender, EventArgs e)
        {
            if (this.lvw_info.SelectedItems.Count == 0)
            {
                return;
            }
            string target = this.lvw_info.SelectedItems[0].SubItems[1].Text;

            try
            {

                System.Diagnostics.Process.Start("IEXPLORE.EXE", target);

            }
            catch (Exception other)
            {
                MessageBox.Show("无法打开IE");
            }

        }


        public void initConfig()
        {
            try
            {

                this.timeout = int.Parse(this.cmb_timeout.Text);
                this.maxThead = int.Parse(this.cmb_threadCount.Text);
                this.sleepTime = int.Parse(this.cmb_sleepTime.Text);
                this.up404 = this.chk_404.Checked;
                this.zwup = this.chk_zw.Checked;
                this.ipup = this.chk_ip.Checked;
                this.showCode = this.txt_statusCodes.Text;
                this.tmpCount = 0;//目录扫描次数启动
                this.success = 0;//扫描完成域名数
                this.scanCount = 0;//目录扫描次数
                this.usedtime = 0;//扫描完成域名数
                this.sucess_result.Clear();
                this.method = this.cmb_http_type.Text;
            }
            catch (Exception e)
            {
                MessageBox.Show("设置错误,请重新配置扫描!");
                this.btn_start.Enabled = true;
                return;
            }

        }

        public void scanThread()
        {
            serverinfos = new ServerInfo[this.list_domins.Count];
            //先智能识别404,指纹,IP
            int index = 0;
            if (this.up404||this.zwup)
            {
                String[] copyList_domians = new String[this.list_domins.Count];
                //复制一个操作,以便去掉超时的域名
                this.list_domins.CopyTo(copyList_domians);
                foreach (String weburl in copyList_domians)
                {
                    if (status != 1)
                    {
                        break;
                    }
                    index++;
                    this.weburl = weburl;
                    ServerInfo svinfo = new ServerInfo();
                    svinfo.id = index;
                    svinfo.domainid = index-1;
                    svinfo.upzw = this.zwup;
                    svinfo.upip = this.ipup;
                    svinfo.up404 = this.up404;
                    svinfo.url = Tools.updateTheDomain(this.weburl);
                    //初始扫描线程
                    initThread(svinfo, 1);
                }
                //等待指纹识别完成后,目录扫描
                while (list_th.Count > 0)
                {
                    clearThread();
                    Thread.Sleep(20);
                }
            }
            //更新总数
            this.lbl_domainSumCount.Text = this.list_domins.Count + "";
            if (this.up404)
            {
                index = 0;
            }
            //判断是否添加后缀
            String ext = this.cmb_ext.Text;
            if (ext.Equals("后缀"))
            {
                ext = "";
            }
            for (int i = 1; i <= this.list_domins.Count; i++)
            {
                if (status != 1)
                {
                    break;
                }
                this.weburl = this.list_domins[i - 1];
               
                for (int j = 1; j <= this.list_dirs.Count; j++)
                {
                    if (status != 1)
                    {
                        break;
                    }
                    ServerInfo svinfo = new ServerInfo();
                    svinfo.domainid = i - 1;
                    svinfo.up404 = this.up404;
                    //取出对应的404信息
                    if (this.up404)
                    {
                        try
                        {
                            svinfo.code = serverinfos[i - 1].code;
                            svinfo.length = serverinfos[i - 1].length;
                        }
                        catch (Exception e) {
                        
                        }
                    }
                    String dir = list_dirs[j - 1];
                    svinfo.url = Tools.updateTheDomain(this.weburl) + dir + ext;
                    svinfo.id = i * j + index;
                    //初始扫描线程
                    initThread(svinfo, 2);
                }
                //扫描完成一个域名
                success++;
            }
            stopScan();
        }
        private void btn_start_Click(object sender, EventArgs e)
        {
            if (status == 0)
            {
                if ("".Equals(this.txt_web.Text))
                {
                    MessageBox.Show("请输入域名或者选择导入扫描字典!");
                    return;
                }
                this.btn_start.Enabled = false;
                {
                    //单个网站扫描
                    list_domins.Clear();
                    String domain = Tools.updateTheDomain(this.txt_web.Text.Trim());
                    list_domins.Add(domain);
                }
                initConfig();
                this.lvw_info.Items.Clear();

                this.timer_usedtime.Enabled = true;

                status = 1;
                //开始扫描
                th = new Thread(new ThreadStart(scanThread));
                th.Start();
            }
            else {
                MessageBox.Show("上次任务还没停止,请停止上次任务!");
            }
        }

        private void cmb_dic_SelectedIndexChanged(object sender, EventArgs e)
        {
            //加载对应的url字典
            loadScanDirs("dic/" + this.cmb_dic.Text);
        }

        public void loadScanDirs(String path)
        {
            //加载对应的url字典
            this.list_dirs = FileTool.readFileToList(path);
            this.lbl_dirs_sum.Text = this.list_dirs.Count + "";

        }

        private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            Environment.Exit(0);
        }

        private void cmb_sleepTime_SelectedIndexChanged(object sender, EventArgs e)
        {
            this.sleepTime = int.Parse(this.cmb_sleepTime.Text) * 1000;
        }

        private void btn_import_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog { Filter = "文本文件(*.txt)|*.txt" };
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                this.txt_web.Text = ofd.FileName;
                this.list_domins = FileTool.readFileToList(ofd.FileName);
                this.lbl_domainSumCount.Text = this.list_domins.Count + "";
            }
        }

        private void tsmi_exportZWInfo_Click(object sender, EventArgs e)
        {
            try
            {
                if (this.serverinfos.Length <= 0)
                {
                    MessageBox.Show("没有找到数据!");
                    return;
                }

                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter = "文本文件|*.txt";
                if (saveFileDialog.ShowDialog() == DialogResult.OK)
                {

                    //保存文件
                    FileStream fs = new FileStream(saveFileDialog.FileName, FileMode.OpenOrCreate, FileAccess.Write);
                    StreamWriter sw = new StreamWriter(fs);
                    foreach (ServerInfo sv in this.serverinfos)
                    {
                        sw.WriteLine(sv.url + "----" + sv.server + "----" + sv.powerBy + "----" + sv.ip);
                    }

                    sw.Close();
                    fs.Close();
                    MessageBox.Show("导出成功!");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("导出数据发生异常!");
            }
        }

        private void tsmi_exportDirInfo_Click(object sender, EventArgs e)
        {
            try
            {
                if (this.sucess_result.Count <= 0)
                {
                    MessageBox.Show("没有找到数据!");
                    return;
                }

                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter = "文本文件|*.txt";
                if (saveFileDialog.ShowDialog() == DialogResult.OK)
                {
                    //保存文件
                    FileStream fs = new FileStream(saveFileDialog.FileName, FileMode.OpenOrCreate, FileAccess.Write);
                    StreamWriter sw = new StreamWriter(fs);
                    foreach (ServerInfo sv in this.sucess_result)
                    {
                        sw.WriteLine(sv.url + "----" + sv.code);
                    }
                    sw.Close();
                    fs.Close();
                    MessageBox.Show("导出成功!");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("导出数据发生异常!");
            }
        }
        public static int version = 20140407;
        public static String versionURL = "http://www.shack2.org/soft/swebscan/version.txt";
        //检查更新
        public void checkUpdate()
        {
            String[] result = Tools.getHtml(versionURL).Split('-');
            String versionText = result[0];
            int cversion = int.Parse(result[1]);
            String versionUpdateURL = result[2];
            if (cversion > version)
            {
                DialogResult dr = MessageBox.Show("发现新版本:" + versionText + ",更新日期:" + cversion + ",立即转到目标网站更新吗?", "提示", MessageBoxButtons.OKCancel);

                if (DialogResult.OK.Equals(dr))
                {
                    try
                    {

                        System.Diagnostics.Process.Start("IEXPLORE.EXE", versionUpdateURL);

                    }

                    catch (Exception other)
                    {
                        MessageBox.Show("无法打开浏览器");
                    }
                }
            }
            else
            {

                MessageBox.Show("自动检查更新,没有发现新版本!");
            }
        }

        private void txt_web_TextChanged(object sender, EventArgs e)
        {
            this.list_domins.Clear();
        }
        
        private void tsmi_readme_Click(object sender, EventArgs e)
        {
            ReadMe m = new ReadMe("使用说明:
注:智能404识别需要web服务器返回Content-Length头,通过对比Content-Length才能智能识别404页面。
2.HEAD方法,较快,但是智能404识别无法针对目录进行识别
2.使用GET方法,相对HEAD较慢,可以针对目录进行智能404识别 
3.选择后缀后,就是在扫描的每个URL添加一个后缀,后缀可在config.ini里配置
4.通常建议使用30-50个线程,超时时间30秒进行扫描
5.休眠时间为每个线程等待毫秒数,建议设置10毫秒,如果不设置,会大量占用cpu
注:请勿非法攻击扫描,产生任何法律效应与本人无关");
            m.Show();
        }

        private void tsmi_about_Click(object sender, EventArgs e)
        {
            ReadMe m = new ReadMe("软件名称:SWebScan
版本:v3.0
时间:2014/4/6
设计人:shack2
QQ:1341413415");
            m.Show();
        }

        private void tsmi_getNewVersion_Click(object sender, EventArgs e)
        {
            Thread th = new Thread(new ThreadStart(checkUpdate));
            th.Start();
        }

        private void tsmi_goMyBlog_Click(object sender, EventArgs e)
        {
            try
            {
                System.Diagnostics.Process.Start("IEXPLORE.EXE", "www.shack2.org");
            } catch (Exception other)
            {
                MessageBox.Show("无法打开浏览器");
            }
        }

    }
}



已经有 ( 7 ) 位网友对此发表了自己的看法,你也评一评吧! 此文不错,我要推荐-->    推 荐
  • 7楼 发表于:2016-04-08 07:05:27        回复
    博主,链接地址失效了,能重新发布下吗?谢谢!
  • 6楼 发表于:2015-02-06 12:57:06        回复
    度盘已挂啊
  • 5楼 发表于:2012-11-12 06:02:45        回复
    求批量扫描功能!
  • 4楼 发表于:2012-10-17 14:42:31        回复
    最近又收集一批关键目录字典,等空了去重复,后面将会做一个资源平台,到时候大家都可以提交资源,平台提供字典下载,估计要在下个月,这个月很忙,没时间啊
  • 3楼 发表于:2012-10-16 21:57:43        回复
    这个工具管用吗?
  • 2楼 发表于:2012-10-09 21:55:25        回复
    我这有一些目录地址什么的。我提供给你吧!
  • 1楼 发表于:2012-09-22 12:38:40        回复
    支持开源,有时间俺拿来改一下,哈哈
欢迎参与讨论,请在这里发表您的看法、交流您的观点@禁止各种脚本

  • 点击Top
  • 推荐Top
  • 评论Top
更 多>>
本站采用Java语言开发,Spring框架,欢迎朋友们提意见。重新对页面进行布局,修改了程序,方便开源使用,由于本人美工真的不行 ,很少用背景图片,页面基本都用背景色...
主题:无色无味 | 网站地图|
Copyright (c) 2012-2013 www.shack2.org All Rights Reserved. | 空ICP备111111111号 | 程序设计: shack2 Powered by SJBlog v1.0 联系QQ:1341413415