267 karma · joined January 30, 2013
That said, any company collecting PII (or any type of data a customer believes is protected really) as part of their business has a duty of protecting that information.
Unfortunately, you can't trust joe sixpack to make safe and sound decisions as to whether they should sign up and give their contact/personal info to your new random app, let alone evaluate the level of your opsec practices.
Saying "we take the privacy of our customers very seriously" months after a breach and going back to business as usual is not enough, and I think this is true for both startups and big corporations.
One of the earlier comments said "Stop fucking ruining people's lives.", I think it pretty much sums it up even if it's probably a bit extreme. The first step is to stop considering security as an afterthought when you write any piece of code.
Google most likely has a cache cluster within VM's core and their DNS send you there when you're resolving from VM's network (ipv4 case). When attempting to resolve over ipv6, you're not using VM's ip space but that of your tunnel provider. In this case, google's geo dns are likely to send you to another cluster closer to that provider.
link in english.
I'd try to contact them through other means (i.e. phone, email, etc.) to 1) schedule my appointment out of band and 2) notify them that their certificate has expired.
That in itself may be considered a breach of privacy, as it exposes your users to passive capture and profiling.
Also, accessing the content you are hosting might be considered legal in some countries but illegal in others, regardless of if it is public or not.
Case in point: 5223/tcp, used by Apple's Push Notification service (amongst other things). Push notifications not being delivered to so many networks made their users angry and tech support calls (and costs) boom, and had soon 5223/tcp unblocked, even on free, non-encrypted, coffee-shop wifi networks.
I understand that most developers just choose to roll with it these days, but I really believe that putting everything atop of 443/tcp because of clueless/incompetent sysadmins is a huge mistake.
Keeping protocol stacks small, efficient and secure should be a design goal.
It is safe to assume that they won't be allocated in the future. You can easily assign them to your loopback interface. e.g. on linux:
$ ip addr add ::2/128 dev lo
You will then be able to use them over loopback just like ::1, and can populate your /etc/hosts file accordingly. $ ping6 -c 1 ::2
PING ::2(::2) 56 data bytes
64 bytes from ::2: icmp_seq=1 ttl=64 time=0.078 ms
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.078/0.078/0.078/0.000 ms
[1] http://tools.ietf.org/html/rfc4291#section-4EDIT: formatting.
Only a subset of the available OS and processor architectures will be supported.
Flash was designed years ago and even though everyone wants it to die, we're still feeling its pain. Designing a similar solution in 2014 is just asking for trouble for the next 10-20 years IMO.
Oh, and you're giving up the opportunity/right to audit the code that runs on your devices.
When they do, most pain points caused by NATs will go away, and that's not webrtc specific. While you'll always encounter some (intentionally?) broken network which only allows 80/tcp and 443/tcp from time to time, there's not much you can do about it, and webrtc can't do much about it.
At least on Linux and OSX, getaddrinfo() won't return ipv6 addresses if the local machine doesn't have any global ipv6 address, which means that a server without ipv6 connectivity won't waste any cycle trying to use addresses it can't reach.
Preferring v4 means that you'll never shift your traffic over to v6 unless v4 is shut down. Because networks and services are going to be dual stack for as long as sysadmins see substantial v4 traffic, such behavior will create another chicken and the egg problem.
It will also put more strain on the network (as traffic will eventually have to go through multiple layers of NAT, etc), render operations more difficult (how do I know who made that request if an entire datacenter is behind one or two ip addresses?), and in the end, make network operations more expensive, because we'll have to run dual stack longer than necessary.
http://www.dslreports.com/forum/r27251137-IPv6-Time-Capsule-...
1. https://github.com/joyent/node/blob/master/src/cares_wrap.cc...
2) Add firewall rules to allow inbound traffic over ipv6 if they don't already exist. If using ufw (default in ubuntu), check that `ufw status` lists entries for ipv6.
# ufw status
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443/tcp ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp ALLOW Anywhere (v6)
443/tcp ALLOW Anywhere (v6)
Allowing inbound https connections over both ipv6 and ipv4 is as easy as typing ufw allow 443/tcp
If you're managing your firewall rules by hand, do NOT block icmpv6 as it will break connectivity.3) add a AAAA record pointing to your vps' ipv6 address to any domain name pointing at your vps. To find that address, use a command like
ip -6 address | grep global
on your vps.Make sure the TTL of your AAAA records matches that of your A records.
If you're hosting your own mail server, make sure your MX records point to host names returning ipv6 addresses. If using SPF, you'll need to add ipv6 addresses to your records as well.
4) Check that your DNS records return both ipv6 and ipv4 addresses, i.e. host should return something like:
$ host www.rackspace.com
www.rackspace.com is an alias for www.wip.rackspace.com.
www.wip.rackspace.com has address 173.203.44.116
www.wip.rackspace.com has IPv6 address 2001:4801:1221:101:1c10:0:f5:116
Changes in DNS can take time to propagate (depending on the TTL of your records), so give it a couple of hours if records don't show up right away,5) test that your services are reachable and working as expected over ipv6. You can use ipvfox (firefox) or ipvfoo (chrome) to make sure that ipv6 was indeed used to reach your web server. curl -6, ping6, telnet -6 are also good to test/debug.
To see what services are listening on ipv6, use nmap to run a portscan (from a different machine than the vps itself).
nmap -6 -P0 -T4 -p0-65535 <domain name or ipv6 address>
6) if you have any kind of monitoring set up to check on your ipv4 services, add monitoring checks for ipv6 as well.
Way too often people forget about this and are not notified when their ipv6 setup breaks.7) run http/https checks with http://ipv6-test.com/validate.php to ensure that connectivity is OK.
Hope this helps :)
Multiplexing allows you to have the same level of concurrency as you currently have with domain sharding without requiring multiple TCP connections (and TLS contexts). Starting and getting a TCP connection up to speed takes a while, especially on congested links (packet loss, spurious retransmits, slow starts, etc.), and TLS just makes the problem worse by requiring multiple back and forth to setup encryption. It also takes quite a bit of memory on servers to maintain hundreds of thousands of TCP socket and TLS states, and a lot of CPU to set up TLS contexts (Diffie Hellman can be quite expensive CPU wise). Then, there are flow-based routers, load balancers, stateful firewalls and other stateful network equipments. We'll get greater performance out of them by using less concurrent connections.
I think moving to a binary protocol and reducing the number of TCP/TLS connections is a very good thing, long overdue IMHO.
EDIT: typos :)
One of three things can happen:
- Both endpoints support MPTCP and announce it through the MPTCP option : MPTCP will be used. Subflows will be set-up if possible (i.e. if additional addresses are present on at least one of the endpoint)
- One of the endpoints (say an ios7 device) supports it, but the other (say a webserver) doesn't : the server will ignore the MPTCP option (which it doesn't understand) and a normal, single path TCP connection will be used.
- None of the endpoints support it, thus no MPTCP option will be sent, normal TCP will be used.
The server should listen on both ipv6 and ipv4 at the same time (on linux at least, if you open a listening socket on ipv6, it will also accept ipv4 connections, so no need for duplicate code) and send advertisements on ipv6 and ipv4 as well.
The client should listen to advertisements on both address families, connect to whatever addresses it discovers : ipv6 first, then ipv4.
Also, having your own discovery/advertisement mechanism has its merits, but have you considered avahi/zeroconf/bonjour?