精华内容
下载资源
问答
  • cookies 第一cookie 和 第3cookie

    千次阅读 2012-10-19 10:30:14
    说到Cookies(中文一般把它称为“甜饼”),经常上网冲浪的朋友一定都听说过。Cookies是从你浏览的网站服务器发送...所谓“第一Cookies”,指的是来自当前正在访问的网站,储存了一定信息的Cookies;所谓“第三Cookies

    说到Cookies(中文一般把它称为“甜饼”),经常上网冲浪的朋友一定都听说过。Cookies是从你浏览的网站服务器发送出来的,并通过你的浏览器,在你的电脑硬盘储存的少量数据。这些数据主要是一些标识码,它们记录了你在Web站点的访问次数,访问时间和你进入站点的路径等等信息。

    所谓“第一方Cookies”,指的是来自当前正在访问的网站,储存了一定信息的Cookies;所谓“第三方Cookies”,指的是来自当前访问网站以外的站点,最常见的就是那些在被访问站点放置广告的第三方站点,这第三方站点可能正在使用Cookies;所谓“会话Cookies”,就是当前浏览时存储的一些信息,在关闭IE的同时,这些Cookies也同时被删除,它一般没什么危害。

     

    话归正题。当微软还没有推出IE8的时候,老实说,我就不喜欢这个浏览器。这不是来自于我对微软的偏见(这个公司确实非常伟大),而是来自于我对Cookie这个美好事物的无比忠诚。但是,IE8的出现,让我们的美好蒙上一层厚厚的阴影。不过,当一切还没有变得非常严重之前,让我们先来了解一下Cookie是什么,它对于我们的意义,以及我们为什么需要捍卫它。

    • 什么是Cookie以及Cookie的作用

      Cookie是在你浏览网页的时候,网站服务器放在客户端(Client End,就是你的电脑)里面的一个小小的TXT文件。这个文件里面存储了一些与你访问的这个网站有关的一些东西,当你下一次访问这个网站的时候,Cookie就会记住你上次访问时候的一些状态或者设置,让服务器针对性的发送页面的相关内容。Cookie里面包含的信息并没有一个标准的格式,各个网站服务器的规范都可能不同,但一般会包括:所访问网站的域名(domain name),访问开始的时间,访问者的IP地址等客户端信息,访问者关于这个网站的一些设置等等。比如,你设置的诸如Google一个页面要显示几条搜索结果之类的信息,即使你不登录你的Google账号,你下次访问时也能够保存下来,这就是上次你访问时把相关信息放入了Cookie的效果。如果是在线购物网站,还记录了一些你的购物车,储物架以及你的账户名等信息。另外有些网站则会通过Cookie把你的登录账号和密码记下来,这样你下次打开浏览器就会自动登录。

     

      当然,如果你在系统文件夹中打开Cookie的TXT文件,你并不会看到这些信息而只能看到一串乱七八糟的字符,因为为了安全起见,Cookie的内容一般都是加密的,只有对应的服务器才能读懂。另外,由于Cookie只是TXT文件,而不是程序,更不是病毒,不能自己运行,不会对操作系统和其他任何计算机程序产生影响,也不会通过互联网传播,因此它对互联网安全实际上不构成威胁。

      对于网站分析而言,Cookie的作用在于帮助嵌入代码类的网站分析工具记录网站的访问(Visit)和访问者(Unique Visitor)的信息,没有Cookie就无法实现相关监测。而通过服务器端Log来进行网站分析的软件则不需要Cookie也能实现相关分析,因此Cookie只对嵌入代码类工具有效。那些你耳熟能详的工具——Google Analytics、Omniture、HBX、WebTrends(嵌入代码版)等等,都需要在网站访问者的电脑上放置Cookie才能实现监测。

    • Cookie的数量和时效

      Cookie的数量是指一个网站可以在客户端放置Cookie的个数。一个网站并不是只能放置一个Cookie在客户端,而是根据需要,会放置多个不同的Cookie。对网站分析工具而言,帮助监测Visit的Cookie和帮助监测Unique Visitor的Cookie就不能是一个,而应该分开设置。对每一个网站(域)而言,不同浏览器能够支持的最多Cookie数是不同的。IE7和FireFox3.0支持每个网站50个Cookie,而Opera则支持30个。无论是30还是50,基本都够用了。

      Cookie的时效(expiration)是另一个非常重要的概念,也是Cookie的重要属性之一。任何Cookie都是有时效的,有些Cookie的有效时间很短,有些Cookie则在浏览器关闭的同时自动失效,而有些则是号称”永久Cookie”。其实,Cookie的时效是在服务器端人为设置的,可以设置为1秒,也可以设置10年,也可以设置在浏览器关闭的同时失效,完全根据不同情况的需要。永久Cookie就是指那些时效很长的Cookie,但不是真的永久。

      Cookie的时效性对于网站分析监测意义重大。Visit的监测依赖于Cookie的时效。例如,Google Analytics对Visit的Cookie设置了两个时效,一个是30分钟,另一个是浏览器关闭时。这就意味着,如果Visit Cookie在30分钟内没有更新,这个Cookie就失效了——这就是为什么我们说Visit这个度量衡量的是间隔不超过30分钟的页面浏览过程,如果两次页面浏览之间的时间超过了30分钟,那么Visit计数会被增加1。另外,如果你打开一个网站,看了一会儿就关掉浏览器,那么当你再次打开浏览器重新开这个网站的时候,即使两次浏览没有超过30分钟,也会被计算为一个新的Visit,原因就是Visit Cookie浏览器关闭时效结束的设置起的作用。

      Unique Visitor也依赖于Cookie的时效。如果这个Cookie的时间设定为2天失效,那么你今明两天都访问同一个网站,Unique Visitor只会记录为从0增加到1;而如果你第三天又来,那么Unique Visitor就会再增加计数一次,共计2次。除了Visit和Unique Visitor外,Return visitor、Frequency等等度量当然也依赖于Cookie的时效。

    • 1st party cookie和3rd party cookie

       第一方Cookie和第三方Cookie其实是一个非常简单的概念,但是我在百度上随便搜索了一些解释,好像都不是很清楚,也不是很准确。实际上,所谓第一方和第三方的说法,是用来确定Cookie的归属的,这个归属是指Cookie中记录的域(domain)。举个例子:如果你访问我的这个网站www.chinawebanalytics.cn的时候,我的网站在你的电脑上设置了一个Cookie,里面的记录的域名也是www.chinawebanalytics.cn,那么这个Cookie就是第一方的,归你访问的网站www.chinawebanalytics.cn所有。而如果你访问网站www.chinawebanalytics.cn时,在你的计算机中设置的Cookie的域名是www.omd.com,那么这个Cookie就是第三方Cookie,归www.omd.com所有。

      对于网站分析而言,这个概念是非常重要的。例如,你会问Google Analytics使用的Cookie是1st party的,还是3rd party的。答案是第一方的。首先,Google Analytics在每个被监测网站上的Cookie都是由我们熟悉的监测javascript代码所创建的(是的,javascript也可以创建Cookie,知道这点就够了,不需要深挖),其次,这个被创建的cookie的域不是analytics.google.com,而是被监测网站自己的域。因此,虽然这个Cookie实际上是在Google Analytics的帮助下建立的,而且也为Google Analytics所用(反而不能被“被监测网站”直接利用),它仍然是第一方Cookie。

      所以,第一方Cookie并不一定需要由某个网站自己的服务器给自己建立,别的网站也能为它建立;而且,第一方Cookie也不一定是能由某个网站自己读取的,它完全可能由第三方读取。第一方和第三方的唯一区别只是:Cookie中的域名是否和被访问网站的域一样,是就是第一方,否就是第三方。

      这真的是一个容易混淆的概念,希望看了我上面的内容您弄清楚了。

      网站分析和所有的互联网广告的监测,都会更喜欢第三方Cookie原因是,第三方Cookie可以用来监测跨网站的访问者行为。例如,DoubleClick使用的就是第三方Cookie,这个公司会为你打开的所有载有DoubleClick广告的页面建立同一个(仅一个)域为DoubleClick的Cookie,这样,只要你打开了这些网页,无论它们是否属于同一网站,你的浏览广告的行为DoubleClick都能知道。但是第一方Cookie就不行了,因为第一方Cookie得用被监测网站的域,这样多个网站就会有多个不同的Cookie,跨网站浏览行为就无法监测了。

      对于大多数浏览器而言,第三方Cookie是被默认关闭的,原因在于人们在讨论Cookie涉及的隐私问题时,倾向于认为第三方Cookie极大的获取了人们的行为隐私,并由此产生了对第三方Cookie普遍的不信任和误解。但事实上,所有的Cookie都不会泄露任何关于浏览者个人的隐私信息,它捕捉的仅仅只是浏览行为本身,第三方Cookie也不例外。而如果所有人都愿意接受第三方cookie,那么网站分析能够给出的分析和优化方案会更多。但可惜,因为第三方Cookie被普遍禁用,因此利用第三方Cookie的监测工具并不多,只有监测网络广告的工具才会坚持使用第三方Cookie。

    • 没有Cookie,还能监测到什么?

      由于第三方Cookie不受欢迎,很少有网站分析工具会采用它。而如果完全没有Cookie,那么网站分析工具几乎无法工作。但实际上,如果没有Cookie,还是能监测到一点儿东西的。这个东西是PV。因为PV的监测只要引发javascript监测代码就可以,跟cookie无关。例如,在Omniture中,如果某个客户端禁用cookie,Omniture还是会记录这个客户端贡献的PV,但完全无法记录Visit,这就会使这个工具监测的PV/Visit会比实际值略大。说点儿题外话:在没有Cookie的时候,Omniture会退而求其次用访问者客户端IP地址来辨别不同的Visitor(Unique Visitor),这样禁用cookie后unique visitor其实还能监测,但由于visit不能监测了,因此有可能在Omniture中出现Unique Visitor大于Visit的情况。

     

      没了Cookie,除了PV,其他的度量基本上就获得不了数据了,所以我会认为没有Cookie,我们什么都没了。或者Visitor和Visitor所在的地理位置还能通过IP地址获得,但众所周知的原因,这个数据是非常不精确的,我们需要Cookie。

      那么,你会问,多少客户端会禁用Cookie呢?我没有精确的数字,但我认为第一方Cookie应该会有大概80%的用户正在使用,只有20%左右会禁用它。而第三方Cookie,由于是默认不开启的,因此我估计顶多只有20%的人在使用它。

      随着IE8的出现,肯定会进一步降低Cookie的使用率,这也将进一步降低网站分析数据的样本数量。我不认为这会降低网站分析工具在描述定性问题时的准确性(定性问题例如Bounce Rate,例如Time on site,以及Returning visitor和New visitor的比例),但在描述定量问题时会出现误差,或者更确切地说会偏小。如果随着Cookie禁用比例的增加,超过50%的人都禁用的话,那么网站分析的原有方法论就会有麻烦了。不过,我肯定不相信Cookie禁用比例会有剧烈的上升,我很乐观——Cookie带给人们的方便远远要比一些不足一提的隐私问题要多的多要大的多。禁用Cookie更多只是心理的慰藉(其实大多数时候一定只是心理上的感觉,而没有什么实际的对安全和隐私的帮助),但带来的不方便则会直接影响你的浏览体验。

      因此,无论是为了我们的专业本身,还是为了让浏览网页的用户有更好的体验,或是为了让网站本身能够创造更多的便利化应用,我们都有足够的理由支持Cookie,反对微软的IE8色情浏览模式,捍卫我们应该捍卫的——这代表着智慧和进步。Eric Peterson写给总统奥巴马的那封公开信值得看看,这代表着我们所有网站分析从业者的最强烈呼声。

    展开全文
  • Firefox扩展,可让用户安全地控制CORS请求,其特定目标是防止浏览器将信息泄漏给第三。 :blue_circle: 什么是CORS? CORS代表跨域资源共享。 简而言之,它是一种用于安全绕过同源策略机制。 :black_small_...
  • 1.先向wx(后称为第三)拿:access_token -> 2.使用拿到access_token 去获取 自己公众号中已关注每个用户openId -> 3.依据openId 给每个用户发送模板信息。 具体细节可查看官方文档 import ...

    步骤为 ->
    1.先向wx(后称为第三方)拿:access_token ->
    2.使用拿到的access_token 去获取 自己公众号中的已关注的每个用户的openId ->
    3.依据openId 给每个用户发送模板信息。
    具体细节可查看官方文档

    第一步:

    @Component
    public class PushAccessTokenTool {
        private static Logger log = Logger.getLogger(PushAccessTokenTool.class);
        public static final String AppId = "AppId";
        public static final String AppSecret = "AppSecret";
    
        public static final String GET_ACCESS_TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid="
                + AppId + "&secret=" + AppSecret;
        public static String access_token = "";
        public static String ACCESS_TOKEN_C8_XCXAPI = "access_token_c8_wchPush"; //Redis存储accesstoken
    
        /**
         * 过期时间7200秒, 因为微信token过期时间为2小时,即7200秒
         */
        private static int expireTime = 7200 * 1000;
        private static TimeUnit refreshTime = TimeUnit.MILLISECONDS;
    
        private static RedisManager redisManager;
    
        @Autowired
        private RedisManager redisManager1;
    
        @PostConstruct
        public void beforeInit() {
            redisManager = redisManager1;
        }
    
    
        /**
         * 获取微信accesstoken
         *
         * @return
         */
        public static synchronized String getAccessToken() {
            return getAccessToken(false);
        }
    
        public static synchronized String afreshAccessToken() {
            redisManager.delete(ACCESS_TOKEN_C8_XCXAPI);
            return getAccessToken(false);
        }
    
        public static synchronized String getAccessToken(boolean refresh) {
    
            access_token = (String) redisManager.getValue(ACCESS_TOKEN_C8_XCXAPI);
    
            if (StringUtils.isBlank(access_token) || refresh) {
                PushAccessTokenTool.access_token = initAccessToken();
            }
    
            return access_token;
        }
    
        private static String initAccessToken() {
            String responseContent = HttpUtil.sendGet(GET_ACCESS_TOKEN_URL);
            JSONObject object = new JSONObject();
            try {
                object = new JSONObject(responseContent);
                String access_token = (String) object.get("access_token");
                redisManager.saveForValue(ACCESS_TOKEN_C8_XCXAPI,access_token,expireTime, refreshTime);
                log.info("access_token重新刷新成功:"+access_token);
                return access_token;
            } catch (JSONException e) {
                try {
                    log.error("获取token失败 errcode:" + object.get("errcode") + " errmsg:" + object.getString("errmsg"));
                } catch (JSONException e1) {
                    e1.printStackTrace();
                }
                e.printStackTrace();
            }
            return null;
        }
    }
    
    

    HttpUtil:

    
    public class HttpUtil {
    
        private static final CloseableHttpClient httpclient = HttpClients.createDefault();
    
        /**
         * 发送HttpGet请求
         * @param url
         * @return
         */
        public static String sendGet(String url) {
    
            HttpGet httpget = new HttpGet(url);
            CloseableHttpResponse response = null;
            try {
                response = httpclient.execute(httpget);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
            String result = null;
            try {
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    result = EntityUtils.toString(entity);
                }
            } catch (ParseException | IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    response.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return result;
        }
    

    RedisManager :

    public class RedisManager {
    	
    	private RedisTemplate<String,Object> redisTemplate;
    	
    	private StringRedisTemplate stringRedisTemplate;
    	
    	private TimeUnit timeUnit;
    	
    	private long expired;
    	
    	/**
    	 * 保存为值
    	 * @param key
    	 * @param val
    	 */
    	public void saveForValue(String key,Object val) {
    		redisTemplate.opsForValue().set(key, val,expired, timeUnit);
    	}
    	
        public void saveForValue(String key, Object val, long expired, TimeUnit timeUnit) {
    		redisTemplate.opsForValue().set(key, val,expired, timeUnit);
    	}
    	
    	/**
    	 * 从value中获取值
    	 * @param key
    	 * @return
    	 */
    	public Object getValue(String key) {
    		 return redisTemplate.opsForValue().get(key);	
    	}
    	
    	@Deprecated
    	public void saveForValueByStr(String key,String value) {
    		stringRedisTemplate.opsForValue().set(key, value, expired, timeUnit);
    	}
    	
    	
    	public void saveForList(List<?> list,String key) {
    		
    	}
    	
    	public void saveForMap(Object val,String key,String hashKey) {
    		redisTemplate.opsForHash().put(key, hashKey, val);
    		redisTemplate.expire(key, expired, timeUnit);		
    	}
    	
    	public Object getFromMap(String key,String hashKey) {
    		return redisTemplate.opsForHash().get(key, hashKey);
    	}
    
    	public RedisTemplate<String, Object> getRedisTemplate() {
    		return redisTemplate;
    	}
    
    	public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
    		this.redisTemplate = redisTemplate;
    	}
    
    	public TimeUnit getTimeUnit() {
    		return timeUnit;
    	}
    
    	public void setTimeUnit(TimeUnit timeUnit) {
    		this.timeUnit = timeUnit;
    	}
    
    	public long getExpired() {
    		return expired;
    	}
    
    	public void setExpired(long expired) {
    		this.expired = expired;
    	}
    
    	public StringRedisTemplate getStringRedisTemplate() {
    		return stringRedisTemplate;
    	}
    
    	public void setStringRedisTemplate(StringRedisTemplate stringRedisTemplate) {
    		this.stringRedisTemplate = stringRedisTemplate;
    	}
    
    	public void delete(String key) {
    		redisTemplate.delete(key);
    	}
    }
    

    第二步:

      /**
         * 获取微信公众号关注用户
         * 官方接口文档:https://developers.weixin.qq.com/doc/offiaccount/User_Management/Getting_a_User_List.html
         * @param access_token
         * @return
         */
        public static Set<String> getUsers(String access_token) {
            String usersGetUrl="https://api.weixin.qq.com/cgi-bin/user/get";
            usersGetUrl+="?access_token="+access_token;
            JSONObject data=getUrlResponse(usersGetUrl);
            Set<String>openIds=new HashSet<String>();
            Integer total=0,count=0;
            try {
                total=(Integer) data.get("total");
                count=(Integer) data.get("count");
                //总关注用户数超过默认一万
                if(count<total){
                    openIds.addAll(getUsers(openIds,usersGetUrl, access_token, (String)data.get("next_openid")));
                }else{
                    //有关注者 json才有data参数
                    if(count>0){
                        JSONObject openIdData=(JSONObject) data.get("data");
                        JSONArray openIdArray= (JSONArray) openIdData.get("openid");
                        for(int i=0;i<openIdArray.length();i++){
                            openIds.add((String) openIdArray.get(i));
                        }
                    }
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
            return openIds;
        }
    
        private static JSONObject getUrlResponse(String url) {
            CharsetHandler handler = new CharsetHandler("UTF-8");
            try {
                HttpGet httpget = new HttpGet(new URI(url));
                HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
                //HttpClient
                CloseableHttpClient client = httpClientBuilder.build();
                client = (CloseableHttpClient) wrapClient(client);
                return new JSONObject(client.execute(httpget, handler));
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    	private static class CharsetHandler implements ResponseHandler<String> {
            private String charset;
            public CharsetHandler(String charset) {
                this.charset = charset;
            }
            public String handleResponse(HttpResponse response)
                    throws ClientProtocolException, IOException {
                StatusLine statusLine = response.getStatusLine();
                if (statusLine.getStatusCode() >= 300) {
                    throw new HttpResponseException(statusLine.getStatusCode(),
                            statusLine.getReasonPhrase());
                }
                HttpEntity entity = response.getEntity();
                if (entity != null) {
                    if (!StringUtils.isBlank(charset)) {
                        return EntityUtils.toString(entity, charset);
                    } else {
                        return EntityUtils.toString(entity);
                    }
                } else {
                    return null;
                }
            }
        }
        
    	private static HttpClient wrapClient(HttpClient base) {
            try {
                SSLContext ctx = SSLContext.getInstance("TLSv1");
                X509TrustManager tm = new X509TrustManager() {
                    public void checkClientTrusted(X509Certificate[] xcs,
                                                   String string) throws CertificateException {
                    }
    
                    public void checkServerTrusted(X509Certificate[] xcs,
                                                   String string) throws CertificateException {
                    }
    
                    public X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }
                };
                ctx.init(null, new TrustManager[]{tm}, null);
                SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(ctx, new String[]{"TLSv1"}, null,
                        SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
                CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
                return httpclient;
    
            } catch (Exception ex) {
                return null;
            }
        }
    
    	private static Set<String> getUsers(Set<String> openIds, String url, String access_token, String next_openid) {
            JSONObject data=getUrlResponse(url);
            try {
                Integer count=(Integer) data.get("count");
                String nextOpenId=(String) data.get("next_openid");
                if(count>0){
                    JSONObject openIdData=(JSONObject) data.get("data");
                    JSONArray openIdArray= (JSONArray) openIdData.get("openid");
                    for(int i=0;i<openIdArray.length();i++){
                        openIds.add((String) openIdArray.get(i));
                    }
                }
                if(StringUtils.isNotBlank(nextOpenId)){
                    return getUsers(openIds,url, access_token, nextOpenId);
                }
            } catch (JSONException e) {
                e.printStackTrace();
            }
            return openIds;
        }
    
    展开全文
  • SMTP称为简单邮件传输协议(Simple Mail Transfer Protocal),一个请求/响应协议,它监听25号端口,用于接收用户Mail请求,并与远端Mail服务器建立SMTP连接。先看API或者上网理解一下SMTP协议传输原理。到邮箱...
    SMTP称为简单邮件传输协议(Simple Mail Transfer Protocal),一个请求/响应协议,它监听25号端口,用于接收用户的Mail请求,并与远端Mail服务器建立SMTP连接。

    先看API或者上网理解一下SMTP协议的传输原理。
    到邮箱账号处打开SMTP协议。
    特别注意:由于安全问题,第三方获得授权码代替密码登录。
    我用的是qq
    message(邮箱提示信息)
    from 发出的邮箱
    to 接收的邮箱
    发送附件:
    <attachments>
    <fileset dir="." erroronmissingdir="false">
    <include name="data.xls"/>
    </fileset>
    </attachments>
    展开全文
  •  (一)什么是第三群发 SP业务中,有一类业务允许A用户通过SP发送信息给B用户,B用户被称为第三。 这样,当运营商取消免费指令后,SP虽然不能直接向非注册A用户发送信息,但是SP却自己购买了少
       		

      为了限制SP群发,运营商在2005-2006年间逐步取消了SP的免费指令。但是这么做并没有起到太大作用,因为运营商关了一扇门,却忘了还开着一扇窗。
      这扇窗就是第三方群发。
      
      (一)什么是第三方群发
      SP业务中,有一类业务允许A用户通过SP发送信息给B用户,B用户被称为第三方。
      这样,当运营商取消免费指令后,SP虽然不能直接向非注册的A用户发送信息,但是SP却自己购买了少量号码作为A用户,然后通过这些号码向大量B用户发送短信。
      这就是第三方群发的原理。
      第三方群发的根源依然是允许SP端口直接向非注册用户发送短信,尽管凭借的是其他用户发送的名义,实质却依然是SP端口群发。
      
      (二)第三方群发的分析
      第三方群发的分析十分简单,只要找出SP用户中MT-MO次数超高的用户即可。
      以下就是个典型案例:
      BLOG38A.JPG
      
      可以看出,一些SP用户的MT次数高达数百万次,这些都是典型的第三方群发。
      
      (三)如何遏制第三方群发
      遏制第三方群发有两种方式:
      1、事后处罚:由于第三方群发很容易分析,特征也十分明显,所以很容易找出来并进行处罚。不过由于是否处罚的权力掌握在极少数人手里,一旦这些人不严管,这类群发依然能够盛行。
      2、彻底封堵:第三方群发的实质就是允许非订购情况下的短信发送,彻底封堵的最好办法就是取消这种业务方式。事实上,正常的第三方业务量极少,基本没有人用,留着这种方式只会给SP群发大开方便之门。何况,原先的业务完全可以变成先发送给A,再由A用点对点方式发送给B的方式,根本不影响业务的开展。
      
      总结一下,第一种方式是人治,第二种方式是律治。第一种方式容易助长权力寻租,所以还是建议采取第二种方式,不仅能彻底封堵群发,而且对所有SP都公平。
      

     

    展开全文
  • 一、 定义重放攻击(Replay Attacks)又称为重播攻击、回放攻击,是指攻击者发送一个目的主机已接收过包,来达到欺骗系统目的,主要用于身份认证过程、破坏认证正确性。 重放攻击可以由发起者、或拦截进行。...
  • 信息的发送方称为 源 1-2. 信息从发送方传输到接收方所通过的媒介称为 介质 1-3. 采用一系列规则指导信息从发送方传输到接收方的整个过程 这些规则称为 协议 1-5. 连续信号称为 模拟信号 1-6. 离散信号称为 数字...
  • 链路层滑动窗口协议

    千次阅读 2016-04-06 11:06:44
    发送方维护一组连续的允许发送的帧的序号,称为发送窗口接收方也维护着一组连续的允许接收的帧的序号,称为接收窗口发送窗口用来对发送方进行流量控制,而发送方窗口大小Wt用来表示还没有收到对方确认信息的情况下...
  • 公钥和私钥解释

    2019-11-02 14:45:51
    对称密钥加密,又称私钥加密,即信息的发送方和接收方用一个密钥去加密和解密数据。它的最大优势是加/解密速度快,适合于对大数据量进行加密,但密钥管理困难。 采用单钥密码系统的加密方法,同一个密钥可以同时用作...
  • 发送窗口用来对发送方进行流量控制,而发送窗口的大小 W 代表在还没有收到对方确认信息的情况下发送方最多还可以发送多少个数据帧。 在接收端设置接收窗口是为了控制可以接受哪些数据帧而不可以接收哪些帧。在...
  • 信源:数据源 信道:通信线路(传送信息...数据通信:发送方将要发送的数据转换成信号,通过物理信道传送到接收方的过程。 数据:信息的表达方式(二进制代码) 注意:在计算机网络中,信息也称为报文(Message)。 2. ...
  • 在实现认证过程中发送方将hash码附于要发送报文之后发送给接收方,接收方通过重新计算hash码来认证报文。Hash函数可提供保密性、报文认证以及数字签名功能。 Hash函数特性: 单向性:对任何给定散列码h,找到...
  • 加密/解密算法大致可以分为对称加密和非对称加密两类:对称加密定义采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。需要对加密和解密使用相同...
  • 拥塞控制 TCP通信的每一方需要执行的一系列行为。这些行为由特定算法规定,用于防止网络因为大...当网络中大量的发送方和接收方被要求承担超负荷的通信任务时,可以考虑采取降低发送速率或者最终丢弃部分数据(也可将
  • 如果发送方使用加密密钥和接收方使用解密密钥不相同,从其中一个密钥难以推出另一个密钥,这样系统称为 () 。 A.公钥加密系统 B.单密钥加密系统 C.对称加密系统 D.常规加密系统 答案:A 解析:这道题和...
  • 处理断点续传算法

    2020-06-04 11:02:55
    但是文件的发送并不是每次都能够成功,可能某一个发送方在发送时,突然掉线,那么接受时,某个文件可能就会缺少一个片段。我们把接下来发送未发送的片段这个操作称为断点续传。那么如果我们要进行断点续传,首先,...
  • 网络信息扫描实验

    2013-05-11 22:05:21
    第三主机是通过其他入侵方法控制主机,扫描结果最终会从第三主机发送给真正入侵者。 端口扫描器是黑客常用工具,目前扫描工具有很多种,例如Nmap、Netcat、X-port、PortScanner、Netscan tools、...
  • C#对称加密算法实现及相关类说明

    千次阅读 2015-08-04 11:11:43
    采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。 需要对加密和解密使用相同密钥的加密算法。由于其速度快,对称性加密通常在消息发送方需要...
  • 一、概念 当两个进程远程通信时,彼此可以...发送方需要把这个 Java 对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为 Java 对象才能正常读取。把 Java 对象转换为字节序列过程称为对象...
  • 双方使用同一个密钥,既可以加密又可以解密,这种加密方法称为对称加密,也称为单密钥加密。 简单来说就是:加密与解密都是同一个秘钥。 优点:通常在消息发送方需要加密大量数据时使用,算法公开,计算量小,...
  • 数据通信基础知识

    2021-02-17 10:16:01
    一个数据通信系统可划分为三大部分,即源系统(或发送端、发送方)、传输系统(或传输网络)和目的系统(或接收端、接收方) 源系统一般包括:源点和发送器 源点设备产生要传输数据(例如从键盘输入字母)源点又...
  • TCP 那些事 | D-SACK

    千次阅读 2018-12-16 21:40:38
    在《【技术】TCP 那些事 | SACK 》讲解了SACK,在SACK中描述数据段是接收端收到数据,发送端根据接收端返回SACK信息就可以知道哪些数据丢了,进而进行重传。...1. 让发送方知道,是发送包丢...
  • 一、概念当两个进程远程通信...发送方需要把这个 Java 对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为 Java 对象才能正常读取。把 Java 对象转换为字节序列过程称为对象序列化。把字节...
  • 一、概念 当两个进程远程通信时,彼此可以...发送方需要把这个 Java 对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再恢复为 Java 对象才能正常读取。把 Java 对象转换为字节序列过程称为对象...
  • 无线播将能量从发送方传送给远方接收者,要发送数据信号经过调制叠加到无线载波信号中,调制后电波占据一定频率带宽。在典型无线lan网配置中,发送/接收设备被称为登陆点,用标准网线连接到局域网中。简单...
  •  协议执行的双方或是多方,也就是人们常说的发送方和接收方.协议的参与者可能是完全信任的人 ,也可能是攻击者或是完全不信任的人 ,比如认证协议的发起者和响应者,证明中的证明人和验证者,电子商务中的商家,银行,和...
  • Tcp可靠性和网络优化

    千次阅读 2017-09-20 21:56:50
    发送方每次发送一个报文段后,接收方必须要回复给发送方已经收到确认信息。 出现差错时候,如果发送放发送了一个报文后,在一段时间内还没收到确认返回,这时候就要重新发送刚才报文,称为超时重传。(发送方的...
  • 数字签名工作原理

    2019-08-24 11:10:31
    数字签名是指发送方用自己私钥对数字指纹进行加密后所得...数字指纹又称为信息摘要,是指发送方通过HASH算法对明文信息计算后得出数据。采用数字指纹时,发送方会将本端对明文进哈希运算后生成数字指纹(还要...
  • 互联网上加密原理

    2019-07-25 09:17:27
     采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。  需要对加密和解密使用相同密钥的加密算法。由于其速度快,对称性加密通常在消息发送方...

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 249
精华内容 99
关键字:

信息的发送方称为