What are the major security concerns for smartphones?

The risks include:

Physical theft
Bad passwords
Badly written code
Bad code segregation
Data loss, interception or theft
MITM
Jamming
etc

You'll have spotted that none of these are new...

And the solutions to these are just the same as they have always been.

Mobile devices are not 'new' from a security perspective. And the only reasons they are interesting are that they are easily stealable, do not yet have a mature and secure code development history, are wireless, and are ubiquitous (especially with a generation who have not grown up as paranoid and privacy conscious as some of us)


What does "This request does not comply with Chrome's Certificate Transparency policy." in Chrome's Security Tab mean?

Chrome's Certificate Transparency policy describes the number of distinct Google and non-Google logs that the certificate must have been logged to at the time it was issued. Certs with longer lifetimes must be logged to more logs in order to be trusted by Chrome. This is a relatively new enforcement (April 2018) so it only applies to certs issued since that date.

The cert for the domain in question was issued 22-Dec-2017 so Chrome still makes an https connection to the affected origin today. When that cert expires 21-Dec-2020 if the new cert also does not comply with Chrome's CT policy then it will not be trusted.


Possible to control desktop data activity LED on Windows or Linux for data extraction?

For Linux at least, there is the LED subsystem that does what you want. From kernel documentation:

  In its simplest form, the LED class just allows control of LEDs from
  userspace. LEDs appear in /sys/class/leds/. The maximum brightness of the
  LED is defined in max_brightness file. The brightness file will set the brightness
  of the LED (taking a value 0-max_brightness). Most LEDs don't have hardware
  brightness support so will just be turned on for non-zero brightness settings.

  The class also introduces the optional concept of an LED trigger. A trigger
  is a kernel based source of led events. Triggers can either be simple or
  complex. A simple trigger isn't configurable and is designed to slot into
  existing subsystems with minimal additional code. Examples are the disk-activity,
  nand-disk and sharpsl-charge triggers. With led triggers disabled, the code
  optimises away.

There is a way to do this without LEDs, by modulating activity on the CPU and turning a computer, even one without a wireless NIC, into a transmitter using a certain frequency. From the abstract of a research paper titled GSMem: Data Exfiltration from Air-Gapped Computers over GSM Frequencies:

  Air-gapped networks are isolated, separated both logically and physically from public networks. Although the feasibility of invading such systems has been demonstrated in recent years, exfiltration of data from air-gapped networks is still a challenging task. In this paper we present GSMem, a malware that can exfiltrate data through an air-gap over cellular frequencies. Rogue software on an infected target computer modulates and transmits electromagnetic signals at cellular frequencies by invoking specific memory-related instructions and utilizing the multichannel memory architecture to amplify the transmission

It is also possible to do by utilizing general-purpose USB devices, such as flash drives. From a similar research paper titled USBee: Air-Gap Covert-Channel via Electromagnetic Emission from USB:

  In this paper we present USBee, a software that can utilize an unmodified USB device connected to a computer as a RF transmitter. We demonstrate how a software can intentionally generate controlled electromagnetic emissions from the data bus of a USB connector. We also show that the emitted RF signals can be controlled and modulated with arbitrary binary data.

Similar techniques can be found by searching for research involving covert data exfiltration on air-gapped computers, particularly when involving electromagnetic emissions.


Why does an anti-forgery token need so many bits?

Your question makes an assumption that should not be made in the field:

wouldn't you be able to detect and lock them out after a few attempts

Yes, in a good working environment there should be a system like this in place that rate-limits failures of various kinds. This is a good thing to do but it should never be your first or only line of defense. If your security model relies on an extra layer like this for its theoretical security, you are introducing an unnecessary point of failure and possible attack vector.
By keeping the the theoretical math that needs to be done out of reach, you reduce the risk posed by things which may be (or eventually end up) out of your control, such as a faulty rate limiter implementation or an inside attack job.


Is email forwarding an altogether unsafe practice?

You're right, but consider this:

Most E-Mail traffic happens in plain text. E-Mails take several hops while being routed to the target mail server. All the routers in between can read the email if they want to. This includes notoriously unsafe home routers which never get security updates.

Finding the target mail server involves MX record retrieval for the domain name. This opens up a whole other venue of attacks. If you manage to convince the sending server that you are the correct destination, you can reroute all emails for a given domain to yourself and then forward them to the actual target, without anybody noticing unless some automated system warns an administrator about changed mx records.

You can easily fake the sender address of an E-Mail, which opens various other avenues of social engineering or pushing your victim into unwise actions because they think they're acting on something someone they trust told them.

E-Mail is unsafe, period. I don't see how adding another level of indirection makes this much worse. There's already a large number of attack venues against the distributed mail system without email forwarding even entering the picture. Following your argument, nobody should ever use E-Mail at all, forwarded or not.

Still, we do, and by and large, see E-Mail as a valuable form of communication. Also, E Mail Forwarding may actually improve security, since you can get a very cheap kind of minimal anonymity by registering throwaway forwarding adresses, switch mail adresses when your old one gets flooded with spam etc (eg use the forwarding in the opposite way - as a temporary address that protects your permanent one).


There are 2 formats in msfvenom. Executable formats and transform formats (see Metasploit unleashed).
The first one will create an executable of some sort. exe will create a Windows executable. Elf will create a Linux executable. Psh will create a powershell script you can execute right away. And so on.
The transform formats format the payload in the given format so that you can include it in a program of the same format. if you provide "C" here you will get an array of unsigned char. Up to you to use it in your C source code. You will most probably use the transform-format when writing an exploit and sending the payload over the network. If the exploit is written in ruby you'll want the payload as ruby array.
I just tried format "raw": It seems to output the payload as pure binary executable code. Don't know what one would use that for, didn't happen to me yet.


Who is the Mandatory Access Control Administrator

You're hitting upon one of the dirty secrets of infosec: MAC and DAC are fundamentally the same thing. They both provide access control, they just have different concepts what a "user", an "administrator", and a "resource" are. There's a reason that MAC didn't become popular until the age of computers administered by people who don't actually use them themselves: on a multi-user mainframe, DAC ACLs set by root look a lot like MAC in practice.

Conversely, take an example of a state-of-the-art "pure" MAC system: Apple's seatbelt profiles, based on BSD's kernel-enforced MAC, are famously used in iOS to prevent even the owner of the device from running anything outside of a sandbox. The real permissions in this case are provided by "entitlements": XML files with a list of perms signed by Apple and included in the binary. In this system, Apple is the MAC admin. No one has a problem calling this MAC, though it looks a lot more like DAC on their own engineering models, where they sign some magic code to let them break the rules.

The real difference between MAC and DAC systems is that MAC systems typically have a more comprehensive notion of the resources to which access is controlled. DAC generally will not prevent you from opening a network socket; MAC might. MAC might prevent IPC; DAC probably won't. Allowed system calls are pretty granular in MAC, not so much under DAC.

Of course, you could get many of the same effects by partitioning programs into individual user accounts and using DAC, because MAC and DAC are fundamentally homomorphic. They just differ in which philosophies they best align with.


What are things we look to find Access Control Database?

What kind of stuff can an attacker do with this vulnerability?

I will assume that my request looks like this: GET /editPassword?userID=163495&password=myNewPassword

In this case, an attacker can simply change the userID and thus edit the password of another user. Even if it's just read access, by having the user supply the ID, it can be changed to arbitrary values, even if your application always sets it to the "correct" IDs.

  How can an attacker exploit this vulnerability?

That entirely depends on the application, and what you consider an exploit.

For example, on Stack Exchange, I can look at people's profiles, knowing just their IDs. Maybe this is what you want, maybe not.

If your only defense against anybody viewing any content in the database is just that they never try to insert a different ID, then you don't have any defense at all.

  How can we determine if it's an actual issue?

Again, depends on your application. Is it okay that users can read arbitrary records? If so, then it's fine. Otherwise you need to add some kind of authorization mechanism, to see if the request is authorized to view this information.

  Any suggested remediation for this vulnerability?

Depends on your codebase. I can't fix your code by knowing 2 lines of it.


Since you mentioned in the comments that this is a remote linux machine accesible over the internet. I would setup SSH with 2-factor authentication.

Example of SSH-2FA: https://www.digitalocean.com/community/tutorials/how-to-set-up-multi-factor-authentication-for-ssh-on-ubuntu-14-04

Also, you mentioned it is for personal use, so if they were able to have access to the machine in the first place, like you mentioned they would be able to reverse engineer your program even with the password approach, since its assumed they have access to your machine, they can just install some kind of monitoring software/keylogger and capture the password.

As mentioned by dandavis, PBKDF2 can be used:

"PBKDF2 applies a pseudorandom function, such as hash-based message authentication code (HMAC), to the input password or passphrase along with a salt value and repeats the process many times to produce a derived key, which can then be used as a cryptographic key in subsequent operations. The added computational work makes password cracking much more difficult, and is known as key stretching." Source: https://en.wikipedia.org/wiki/PBKDF2

But overall, since it is only running on your personal machine, I would focus on securing the machine itself then worry about the application. Setup some firewalls rules and SSH with 2FA would be my suggestions.


How can I tell if BitLocker is successfully enabled on remote hosts?

With this PowerShell command, you can check the BitLocker status on a volume:

Manage-bde -status -cn <computername/ip> <drive letter>

Where the -cn argument is optional. Examples:

Manage-bde -status C:
Manage-bde -status -cn 192.168.1.2 C:

The command can also be run remotely.

Reference:
https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/ff829849(v=ws.11)


Do the Spectre and Meltdown CPU bugs affect AMD in addition to Intel?

Spectre works by causing the CPU to speculatively execute code selected by the attacker in the context of the target process.  It does this by getting the branch predictor to guess incorrectly about which way an upcoming branch instruction will go, then looking for side effects of the code whose execution was discarded.  Any CPU that performs speculative execution is vulnerable to Spectre, although if the branch predictor is primitive enough (eg. the 68040's "always take the branch" prediction) or doesn't support predicting indirect branches, Spectre is much harder to make use of.

Meltdown works by speculatively reading protected memory.  On Intel, the protection status of the memory isn't checked until the CPU decides that yes, the "read protected memory" branch of the execution path is the correct one.  In the meantime, observable side effects will have taken place.  AMD states that their CPUs check the protection status earlier and are not affected, and the authors of the Meltdown paper say that they were unable to get the attack to work on ARM.


Malware Analysis for Internet of Things Malware

Generally, for malware analysis, there are 2 different approaches. Security Developers try to hunt malware according to their static and dynamic features. As I know all of the IoT malware analysis techniques are using static features and they are based on the OPCODEs generated by the malware.
The other approach is based on dynamic features of the malwares. Dynamic features are the behavioral characteristics of the softwares when they are running. For example api calls or permission requests of the software. Generally to investigate the dynamic features you may need to run the malware in a secure environment like sandbox. However; as i know there is no the dynamic feature based approach for IoT ecosystem.
Lastly, yes, there is only one IoT malware dataset based on ARM architecture.


Is ECDH for SEC P-384 and P-521 broken in Windows 10 / Windows Server 2016 TP3?

Update: Fixed in KB3093266 (https://support.microsoft.com/en-us/kb/3093266)

Run the following in a PowerShell window to see if you have it ...

Get-HotFix -id KB3093266

Sources confirm that this is indeed a bug. The issue related to parsing PFX files in Windows 10 and Windows Server 2016 Beta when the certificates and private keys are initially installed.

The fix should be out in a security update sometime in Sept 2015. Honestly, we're pretty surprised to be the only ones really using elliptic curve crypto on Windows since ours seems to be the original report.


Questions on reflected file download (RFD) attack

Google is not hosting ChromeSetup.bat. A requirement for this attack is that a website needs to have an endpoint with a less common Content-Type and preferably a misconfigured Content-Disposition header (namely: no 'filename' attribute). These two headers will cause the browser to download the response as a file, instead of rendering it.

In the URL you provide that endpoint is '/s' which provides autocomplete suggestions as JSON, with a content type of application/json. Older versions of IE will prompt a download just based on the content type, newer versions and Chrome require that incomplete content-disposition header for this attack to work.

Another requirement is that this endpoint must reflect some user input from the querystring ( post or cookie data will obviously work aswell but wouldn't be as effective for the attacker). This will provide the malicious content of the file that is downloaded.

In the URL you provided this will be the value of the querystring parameter.

As no filename is provided for the download, the browsers tries to pick one. Because the Google website allowed loose urls through url parameters (the ;/ChromeSetup.bat; part), the browser picked a cleaned up version of that (namely ChromeSetup.bat) as the filename to present to the user. The webapplication ignores this input, but the browser does use it.

Any browser on any OS might respond in this way. Chrome will download the response with the forged filename, that will also work on OSX.

An additional weakness exists in Windows that doesn't warn the user properly when "setup" occurs in the filename. Windows will also directly run a .bat file if you click it. Osx and Linux won't run this file as the attacker would most likely be unable to provide a full shellscript with the hashbang notation. Even then, it doesn't have the executable bit set, so it wouldn't be run directly.

The user still has to activate/accept the download, so just driving by with an  won't cause immediate "infection". A client (browser) should provide proper warnings for executable files instead of just running them. The user should know better than to run random .bat files, but that's the strength of this attack: the "file" is served from Google.com, so it should be safe right? The most important party here is the vulnerable website: the website shouldn't allow a user to provide a custom path, should provide proper headers to prevent this and should reconsider reflecting user input.


When to change a smartphones with out-of-support OS's?

Sorry for being too frank, your answer is a big YES, it shouldn't be used anymore - at least it shouldn't be connected to the net if you don't wanna change your device. It's twenty-first century and we're living in the age of IoT (Internet of Things). Security, is the most important thing in everyone's life since what we are dealing with - daily, hourly or secondly - is DATA! And most of those people not working a lot with Computers, are keeping their Data in their smartphone!
Updates are not only meant for more compatibility with newer applications with new enhancements, they are meant to patch vulnerabilities, pitfalls, and security breaches. When vulnerabilities don't get patched, attackers can easily use them as your weak-point, to access to your Data, you data will lead them through your life, your life can even mean your house if you have a smart house! Afterwards it will lead them to gain access to other's lives whom are in relation with you, and so on!!! It's like a tree with thousands of branches. One master card means thousands of master cards - if the attacker who has gained access to yours is an expert!
On the other hand, consider someone willing to hack a governmental agency, or an organization, or etc., they can hide and cover their tracks behind yours, they can throw you in trouble to escape from trouble.
Being up tp date, means safety, not only yours, but also your loved ones. Please consider being up to date a serious thing.
I'm a Linux System Administrator and System Architect responsible for System-Level Security for such things - I should test things sometimes as a penetration tester, so I'm not exaggerating, I've seen all those I mentioned.
If you need an example:
From WikiPedia:

Dirty COW (Dirty copy-on-write) is a computer security vulnerability for the Linux kernel that affects all Linux-based
operating systems including Android. It is a local privilege
escalation bug that exploits a race condition in the implementation of
the copy-on-write mechanism in the kernel's memory-management
subsystem. The vulnerability was discovered by Phil Oester. Because of
the race condition, with the right timing, a local attacker can
exploit the copy-on-write mechanism to turn a read-only mapping of a
file into a writable mapping. Although it is a local privilege
escalation bug, remote attackers can use it in conjunction with other
exploits that allow remote execution of non-privileged code to achieve
remote root access on a computer. The attack itself does not leave
traces in the system log. It has been demonstrated that the bug can be
utilized to root any Android device up to Android version 7.
The bug has been lurking in the Linux kernel since version 2.6.22
released in September 2007, and there is information about been
actively exploited at least since October 2016. The bug has been
patched in Linux kernel versions 4.8.3, 4.7.9, 4.4.26 and newer.

N.B. I recommend you use 4.9 if you're a linux user.
You can check the following link to find the codes and further information:
https://dirtycow.ninja
By the way, it makes no odds if you're using smartphone or a computer to keep your data in, the only thing matters is that your keeping your data, even your sensitive data sometimes. Either your smartphone and Computer have something called OS that are running atop something called Kernel! What would it be if kernel never gets newer updates? Kaboom! Compromised, no matter if you are an important person or a normal guy, you'll be compromised because your address - IP, MAC, Device anything, - will be considered as either a bait, or an aim.


Find the Encryption Key (used for network encryption) assuming a Trust Chain is being used on Windows?

I think you mean what Microsoft calls Your Public Key Used for Encryption here.

And in that case you're simply looking for the Public key field.


Any practical Single Sign-On (SSO) protocol/traffic analysis tool/method/analyzer?

Here is the presentation on SSO theory -- [PDF] https://www.compass-security.com/fileadmin/Datein/Research/Praesentationen/area41_2016_saml.pdf [PDF] -- that introduced the SAMLRaider BApp for Burp Suite -- http://www.toolswatch.org/2015/12/new-tool-saml-raider-v1-1-1-saml2-burp-extension/

Another great BApp for Burp Suite, SAMLReQuest, is detailed here -- https://www.insinuator.net/2016/06/samlrequest-burpsuite-extention/

This author went into detail for an XXE security bug found in a SAML app -- https://seanmelia.wordpress.com/2016/01/09/xxe-via-saml/ -- but I really enjoyed this post from the SendSafely and Gotham Digital Science teams -- https://blog.sendsafely.com/web-based-single-sign-on-and-the-dangers-of-saml-xml-parsing


Is it correct to say that AVs use the same signature-based detection methods in emulation as they do on static binaries?

Disclosure: I work for an anti-malware vendor.

The answer is "it depends on malicious content".

If the malicious content is obfuscated or encrypted, but otherwise it is the same content which would be detected if not encrypted - the static analysis rules would be applied after the obfuscation/encryption layer is stripped down. The stripping in this case may involve proprietary decoders, emulators or other things. So for this case the answer would be "yes".

However if the malicious content is polymorphic/metamorphic, it cannot be stripped down to plain malicious content - there is nothing to unpack/decrypt. In this case the emulator or similar engine would be used to find out what exactly the malware is doing, and apply a different set of detection rules here. So for this case the answer would be "no".


Cookies can be used to keep you logged in to a website, track your browsing history, log your activity and preferences on a website, and some other things. Rejecting cookies prevents this information from being tracked and easily available to the site owner or third-party affiliates. It will also, of course, prevent attackers from accessing or abusing the data through a number of means such as XSS, CRSF, DNS cache poisoning, traffic sniffing, local system exploitation, etc.

I suggest you read more about HTTP Cookies on Wikipedia, and search the web for further details as well. The following sections of the Wiki entry will probably be of particular interest to you:

Uses
Privacy and third-party cookies
Cookie theft and session hijacking

There are some down-sides to rejecting some cookies.

Your authentication to a website will not persist across sessions - you will have to log in again every visit.
Your preferences on a website may not be saved, or may not be available until you login.
You may not be able to use a shopping cart on e-commerce websites.
Other site features that rely on cookies will not function.

Just like any security measure, the choice of allowing or rejecting cookies for any site, or for third-party hosts, comes down to how you want to balance security vs. usability.


API authentication without Oauth2 server

Just to be sure we're on the same level: 'oAuth' is not 'OpenID'. 'OpenID' is about authentication (proving who you are), while 'OAuth' is about authorisation (to grant access to things without having to deal with the original authentication). It's 'OAuth' that can be used in external partner sites to allow access to protected data without them having to re-authenticate a user.

To answer your question: I'm wondering that you want to go through the hassle of figuring out alternatives when plenty of simple libraries exist that allow you to implement oauth in a clean and (more important) official way. Instead of thinking you actually have to 'setup your own oauth2 server', you might want to take a look at http://oauth.net/code/ as there's no reason to do that to handle oauth for authorisation as part of your API's user authentication... just use your domain as your OpenID Provider.


Is loss of conversation history inherent to end-to-end encryption?

No, loss off message history isn't inherent to end to end encryption, but it's inherent to forward secrecy.

It might be either the Wire developer conflating between e2e and FS, or they consider FS to be a crucial component of e2e, which is not entirely unreasonable viewpoint but is not one that's common.


Can you post an image without blurring information...
Maybe you're just adding a blank space on the ESSID and jumping a command, add quotes on strings, like this:

airbase-ng -c 11 -a AA:AA:AA:AA:AA:AA --essid 'I use blanks on my essid' wlan0mon

Try this to test:

airbase-ng -c 2 --essid test -a AA:AA:AA:AA:AA:AA wlan0mon

or without the -a (Use your default MAC)

airbase-ng -c 2 --essid test wlan0mon


SSH Bad Protocol Version Identification String- What is it?

This is octal representation (base 8). During the initial steps of a SSH connection, the client and the server send each other the version(s) of the protocol they implement, as strings. These strings must follow a specific format.

Here, your server received from the client a "protocol version" string consisting of five bytes, of value 128, 226, 1, 3 and 1, in that order. This is not a "protocol version string" which makes sense. Probably, the client was not trying to do some SSH at all, but instead some other protocol.

A lot of virus try to propagate automatically that way: by trying known vulnerabilities of some protocols on random IP addresses and ports. So any publicly reachable server (like your SSH server) will get that kind of noise. Best thing to do is to ignore it altogether.


The answer is no... at least not how you're thinking of it working.  XSS attacks actually happen on the client's browser.  You could use an XSS to attack the site administrator.

I mean, theoretically, the answer is yes, but not as you likely envision it happening.  There are a lot of IFs involved, but only if you could store a XSS attack on that web application; if victim has disabled their client's default security controls and allows the browser to make calls back to a server you control. However, the default controls in place in modern browsers that would likely prevent this from being successful.

That said, this is basically one of the methods drive-by malware is delivered.  Target users with administrative privileges and you gain access to their machines.

You don't need a full reverse shell to compromise the application.  If you know the application well, your XSS attack, could in fact be a CSRF attack that targets admin user rights to perform administrative actions on the server on your behalf.


Can malware cause firefox to send GET requests?

Yes it can, for example using :

Ajax
A reference to an external JS or css file
An iframe
or even a HTTP 302 redirect.

This can be used by online malware to generate trafic for a DDoS Attack.

Note, all those are used for legitimate purpose on many (most) websites, and hence do not imply a malicious behavior.

In response to your edit: Yes, Ajax can do this, although I don't think I've already seen this for SQL Injections (whereas XSS or XSRF for example are frequently exploited this way). Other possibilities might include that your server has been compromised and is used as a proxy by an attacker to conduct SQL Injection attacks, or you are running a Tor exit node that is used by an attacker (whether you know it or not).


Are PS/2 devices a risky piece of hardware for modern point of sale devices to be using?

TempleOS is a hobbyist OS designed to be God's temple developed by the late Terry Davis, a man who had severe schizophrenia.* Despite being an excellent programmer with a deep understanding of hardware, almost nothing he said was rooted in reality. Many of his design features came from his belief that God wanted it that way. He also believed that the CIA (in addition to glow-in-the-dark space aliens and African Indians) were out to get him. I would not take any of his claims seriously.

sometimes the BIOS has PS/2 drivers but purposely disables them, just to be mean

This is untrue. A BIOS disabling its PS/2 driver is completely irrelevant to the vast majority of people. It is only relevant to hobbyist OS developers who use the built-in BIOS drivers, instead of writing their own as they should. A BIOS disabling its PS/2 driver will not impact any contemporary operating system that wishes to directly interact with the hardware (and no modern OSes use BIOS calls).

Perhaps, at a point of sale in a store, a thief could hack a credit card machine.

The PS/2 protocol is not authenticated, but neither is USB. Any man-in-the-middle between the PS/2 device and port would be able to sniff and inject keystrokes, but this is not considered an issue as it requires physical access to a computer to pull off (inserting a hardware keylogger). However, it is illogical to conclude that this allows someone to hack a PoS system using PS/2.
* I have personally witnessed him, on IRC, spend more than 12 hours straight talking to a markov bot he created with text from the Bible. It was a highly surreal experience.


Yes, the app stores your password an uses it to authenticate every time it queries your mail account. This is no different from a stationary mail client like Outlook or Thunderbird.

The password is not transmitted in clear over the network. It is either sent through a TLS encrypted connection or used in a challenge/response authentication scheme. So it is reasonably secure against interception.

In a public WLAN, there's an increased possibility of man-in-the-middle attacks, so you should make sure that your device is reasonably secure against that, for example by properly checking TLS certificates. If in doubt, use a VPN tunnel. This holds for all network services, not just E-mail.


Is there any way of making an SQL server think I'm accessing from localhost?

Obvious answer: Make a local connection.

In other words, unless the network stack (of the operating system) is buggy, or someone grossly misconfigured e.g. port forwardings on the machine your database runs on, the only way to do that is by actually opening a connection from the machine your database runs on itself.

Now, in the year 2016, I'd say it'd still be totally unacceptable to offer unauthorized access based on host alone – you simply don't do that, since there's no cost to authentication.

A proper way of doing "safe" local-only networking is to not use IP sockets, but good ol' unix sockets, which can be secured using normal file access privilege systems.


Is it safe to assume that my computer's clock will always be synced with actual time within the second or a few seconds at the worst?

No, in general. Time keeping is an important part of the kernel's duties, but it's not infallible, especially when you're talking about scenarios where other failures are occurring. In general you should not assume that all machines have the correct time in all circumstances, and your security should not depend on this assumption.

The only onboard clock that most computers have is the Real-Time Clock (RTC). This is the clock on your PC's motherboard that historically was powered with a coin cell battery. This clock is typically the default clock for the system, as it is always available. There are many different constructions for this device with varying degrees of accuracy and robustness. Some are just cheap parts that don't work well. Obviously these devices can have bad batteries, in which case they can keep poor time or no time at all. Some constructions are also vulnerable to temperature fluctuations. I've worked with systems in recent memory where the resolution of the RTC was limited to one second, meaning you query the RTC and it only returns a full seconds value, meaning that the reported value can be up to half a second off of the true time (even assuming perfect time is kept).

However, even accurate clocks are only accurate to a certain degree, limited by the accuracy of their crystal oscillators. Most RTCs are spec'ed to have an accuracy of 20 or 30 parts-per-million. This results in a drift of about 1.7-2.5 seconds per day. Some such devices might be more accurate, while others might be less accurate even if they're spec'ed higher. It's not hard to find examples online of people who report drift that is 5-10 times worse than that. This drift must be compensated periodically either manually or through an internet timeserver in order for your machine to keep accurate time.

Note that some systems do not have a RTC, which means they are incapable of keeping accurate time without an internet connection. A notable example of such a system is the Raspberry Pi.

There are other onboard time-reckoning devices such as the Programmable Interval Timer (PIT), High-Precision Event Timer (HPET), and the processor's timestamp counter (TSC). All of these can be used to augment the notion of time that the computer gets from the RTC and internet time servers, but the RTC is the only onboard device that keeps actual time while the computer is unpowered.

Thus, when your computer first boots it uses the RTC to establish what time it is, and then later it will update that notion based on an internet timeserver. It will periodically check in with the RTC and/or internet timeserver to update itself, but between these events it uses those other time sources to keep track of roughly what time it is.

Now how can this system go wrong? If you don't have an internet connection, then the only time source the system can use for the real wall-clock time is the RTC. The RTC will drift, and it might drift up to the tune of 10-20 seconds per day if you're particularly unlucky. The machine normally compensates for this automatically, but if you don't have the internet then this doesn't happen. Even if you had a one-day outage, for example, your machine could drift well outside of your 1-2 seconds parameter with bad hardware.

Second, when a time discrepancy is detected the default behavior is to adjust the clock time gradually rather than setting it instantaneously to the new value. There are lots of processes on the system that are using time and timers constantly (TCP packet timeouts, GUI event loops, etc.) and these processes typically don't take it well when time jumps around. Thus, for a short period of time the clock will artificially run faster or slower than the true time while your clock catches up to the true time. Your clock can even appear to stop, or I've heard in extreme cases run backwards depending on what your specific system implementer did.


Does Google Analytics collect any information about the contents of the web page?

You can install the Google Analytics Debugger Chrome plugin to see the data that is getting sent to Google. I don't believe that it sends any of the page content, other than the page's title and URL (including GET parameters).


Adam Langley (google) wrote a reply to GRC's accusations. it can be found here: https://www.imperialviolet.org/2014/04/29/revocationagain.html

"
ImperialViolet
Revocation still doesn't work (29 Apr 2014)

I was hoping to be done with revocation for a bit, but sadly not.

GRC have published a breathless piece attacking a straw man argument: “Google tells us ... that Chrome's unique CRLSet solution provides all the protection we need”. I call it a straw man because I need only quote my own posts that GRC have read to show it.

The original CRLSets announcement contained two points. Firstly that online revocation checking doesn't work and that we were switching it off in Chrome in most cases. Secondly, that we would be using CRLSets to avoid having to do full binary updates in order to respond to emergency incidents.

In the last two paragraphs I mentioned something else. Quoting myself:

“Since we're pushing a list of revoked certificates anyway, we would like to invite CAs to contribute their revoked certificates (CRLs) to the list. We have to be mindful of size, but the vast majority of revocations happen for purely administrative reasons and can be excluded. So, if we can get the details of the more important revocations, we can improve user security. Our criteria for including revocations are:

The CRL must be crawlable: we must be able to fetch it over HTTP and robots.txt must not exclude GoogleBot.
The CRL must be valid by RFC 5280 and none of the serial numbers may be negative.
CRLs that cover EV certificates are taken in preference, while still considering point (4).
CRLs that include revocation reasons can be filtered to take less space and are preferred.”
In short, since we were pushing revocations anyway, maybe we could get some extra benefit from it. It would be better than nothing, which is what browsers otherwise have with soft-fail revocation checking.

I mentioned it again, last week (emphasis added):

“We compile daily lists of some high-value revocations and use Chrome's auto-update mechanism to push them to Chrome installations. It's called the CRLSet and it's not complete, nor big enough to cope with large numbers of revocations, but it allows us to react quickly to situations like Diginotar and ANSSI. It's certainly not perfect, but it's more than many other browsers do.”

“The original hope with CRLSets was that we could get revocations categorised into important and administrative and push only the important ones. (Administrative revocations occur when a certificate is changed with no reason to suspect that any key compromise occurred.) Sadly, that mostly hasn't happened.”

And yet, GRC managed to write pages (including cartoons!) exposing the fact that it doesn't cover many revocations and attacking Chrome for it.

They also claim that soft-fail revocation checking is effective:

The claim is that a user will download and cache a CRL while not being attacked and then be protected from a local attacker using a certificate that was included on that CRL. (I'm paraphrasing; you can search for “A typical Internet user” in their article for the original.)

There are two protocols used in online revocation checking: OCSP and CRL. The problem is that OCSP only covers a single certificate and OCSP is used in preference because it's so much smaller and thus removes the need to download CRLs. So the user isn't expected to download and cache the CRL anyway. So that doesn't work.

However, it's clear that someone is downloading CRLs because Cloudflare are spending half a million dollars a month to serve CRLs. Possibly it's non-browser clients but the bulk is probably CAPI (the library that IE, Chrome and other software on Windows typically uses - although not Firefox). A very obscure fact about CAPI is that it will download a CRL when it has 50 or more OCSP responses cached for a given CA certificate. But CAs know this and split their CRLs so that they don't get hit with huge bandwidth bills. But a split CRL renders the claimed protection from caching ineffective, because the old certificate for a given site is probably in a different part.

So I think the claim is that doing blocking OCSP lookups is a good idea because, if you use CAPI on Windows, then you might cache 50 OCSP responses for a given CA certificate. Then you'll download and cache a CRL for a while and then, depending on whether the CA splits their CRLs, you might have some revocations cached for a site that you visit.

It seems that argument is actually for something like CRLSets (download and cache revocations) over online checking, it's just a Rube Goldberg machine to, perhaps, implement it!

So, once again, revocation doesn't work. It doesn't work in other browsers and CRLSets aren't going to cover much in Chrome, as I've always said. GRC's conclusions follow from those errors and end up predictably far from the mark.

In order to make this post a little less depressing, let's consider whether its reasonable to aim to cover everything with CRLSets. (Which I mentioned before as well, but I'll omit the quote.) GRC quote numbers from Netcraft claiming 2.85 million revocations, although some are from certificate authorities not trusted by mainstream web browsers. I spent a few minutes harvesting CRLs from the CT log. This only includes certificates that are trusted by reasonable number of people and I only waited for half the log to download. From that half I threw in the CRLs included by CRLSets and got 2356 URLs after discarding LDAP ones.

I tried downloading them and got 2164 files. I parsed them and eliminated duplicates and my quick-and-dirty parser skipped quite a few. None the less, this very casual search found 1,062 issuers and 4.2 million revocations. If they were all dropped into the CRLSet, it would take 39MB.

So that's a ballpark figure, but we need to design for something that will last a few years. I didn't find figures on the growth of HTTPS sites, but Netcraft say that the number of web sites overall is growing at 37% a year. It seems reasonable that the number of HTTPS sites, thus certificates, thus revocations will double a couple of times in the next five years.

There's also the fact that if we subsidise revocation with the bandwidth and computers of users, then demand for revocation will likely increase. Symantec, I believe, have experimented with certificates that are issued for the maximum time (five years at the moment) but sold in single year increments. When it comes to the end of the year, they'll remind you to renew. If you do, you don't need to do anything, otherwise the certificate gets revoked. This seems like a good deal for the CA so, if we make revocation really effective, I'd expect to see a lot more of it. Perhaps factor in another doubling for that.

So we would need to scale to ~35M revocations in five years, which is ~300MB of raw data. That would need to be pushed to all users and delta updated. (I don't have numbers for the daily delta size.)

That would obviously take a lot of bandwidth and a lot of resources on the client. We would really need to aim at mobile as well, because that is likely to be the dominant HTTPS client in a few years, making storage and bandwidth use even more expensive.

Some probabilistic data structure might help. I've written about that before. Then you have to worry about false positives and the number of reads needed per validation. Phones might use Flash for storage, but it's remarkably slow.

Also, would you rather spend those resources on revocation, or on distributing the Safe Browsing set to mobile devices? Or would you spend the memory on improving ASLR on mobile devices? Security is big picture full of trade-offs. It's not clear the revocation warrants all that spending.

So, if you believe that downloading and caching revocation is the way forward, I think those are the parameters that you have to deal with."

i copypasted his blog post without permission but in good faith (that he welcomes it). should he or an affiliated party demand takedown, plz just erase my comment.


What is the best practice for storing a secret on the cloud?

"In the Cloud" means "on a virtual machine which runs on the infrastructure of some big company with which we have a contractual relation". By definition, when you store things "in the cloud", you are trusting the cloud provider. That provider has all the technical power to look at the fine details of the entrails of your code and data and everything you store on these machines.

It's like trying to maintain the integrity of your body, when you are already on the operation table, under general anesthesia, and the surgeon has his scalpel in hand. It's a bit late to mistrust the surgeon...

If the secret is valuable, then don't store it in the cloud. Said otherwise: if you cannot afford the extra cost of a dedicated hardware server, then the secret data cannot be worth that much -- or possibly you are way too much avaricious for your own good.


What are the security benefits of calling and asking to input pin from the website?

Besides proving that the phone number is correct, a verification by phone helps to combat spam. It's much easier to create a high amount of fake accounts with verified email addresses than with verified phone numbers.

Google explains why they do that, too:

  Why Google asks for your phone number to verify your account

  In an effort to protect our users from abuse, we sometimes ask users
  to prove they’re not a robot before they're able to create or sign in
  to accounts. Having this additional confirmation via phone is an
  effective way to keep spammers from abusing our systems.


I don't know whether it will be possible to save a log of what was sent to you, but if I were you, I wouldn't worry about it.  I would leave that to security folks to analyze the details of how you got hacked; if you got picked at random to be hacked, odds are there many others are getting hacked, too, so the professional security companies have a good chance of observing the attack in the wild.

Instead, I would focus on securing your machine so your don't get hacked again, and making sure you eliminate any access to your machine and Yahoo account that the hacker may have gained.  In particular, I would take the following steps as soon as possible:

Immediately change your Yahoo! Messenger password to a temporary password, ideally from another computer if possible but if not, from your own computer.  (This will be just a temporary password, because there's always the possibility that your attacker has infected your copy of Yahoo! Messenger or infected your machine with a keylogger.  We'll try to deal with that next.)
Disconnect your computer from the network.  Reboot.
Run a full virus scan of your computer (most will have an option to do a full scan of the hard disk on demand).  Fix any problems it reports.
Reconnect the network connection.  Ask your virus software to update its anti-virus definitions.  Run another full virus scan.  Hopefully it won't find any problems.
Reboot.  Run Windows Update.  Update all the software it will allow you to update.  While you're there, turn on automatic updates, if for some reason they're not already enabled.
Check for updates to Yahoo! Messenger.  Install any updates.
Download and install Secunia PSI.  Run it.  Fix any security problems it reports (i.e., update any software that it says is out of date).
Reboot if required by any of the previous software updates.
Now change your Yahoo! Messenger password a second time, this time to something permanent and hard to guess.  You might want to change the answers to any security questions, too, just in case.
Also, check over your Yahoo! account profile and details very carefully.  Make sure any email addresses in there are correct (e.g., that the attacker hasn't forwarded your email to another account).  Make sure the attacker hasn't added himself to your buddy list or anything like that.
If you used your Yahoo! Messenger password on any other site or with any other software, change your password for those sites/applications, and do the same with them.

While there are no 100% guarantees, if you follow those steps, I expect you will probably be OK.


MiTM, can a binary file be changed or swapped enroute

Yes.  It can be done.  I've done it personally with python, using a script that I wrote called the-backdoor-factory and implementing a proxy in python.  Once you have the the patching system in place almost any proxy will work.  You will just need to look for the application/octet-stream in the html, retrieve the binary, patch it, and forward to the client.  I'll post a full write up online once I have stable program for community testing.

So here a video of the POC that I'm working on: http://www.youtube.com/watch?v=qPCy2IDaEOI

What you are seeing in the video is my POC on the left written in python and the 'victim' on the right browsing through the proxy.  The proxy looks for binaries and only intercepts PE/COFF at the moment. After the binary is patched, it forwards the binary to the user, as you can tell, it's really fast.


Potential risks of allowing custom javascript

Being able to execute custom code in someone else's environment is the very endgoal of most web exploits. Your design consideration bypasses any pretense of security and facilitates this by default.

The service you'd actually be offering is a platform for anybody to publish malware, adware and drive-by downloads, or to use your service as a node in a botnet.

There are better ways to do what you want to do than allowing execution of arbitrary code.

Theming can be handled through some degree of custom css (look at the subreddit css system).
Comments and hitting third-party APIs can be facilitated through the use of approved widgets or plugins that you write and author based on popular demand.

It's just a bad idea, and there's a reason only a limited few sites (jsfiddle, etc) allow execution of arbitrary code-- they're sandboxed to hell and back again, and implement modified interpreters that don't allow execution of potentially malicious commands (eval(), etc).


How common is steganography in real world applications?

Given your comment I will skip the historical info but if you want you can read it in this paper.

The answer to your end question is yes, it's being practically used.
The following malware programs and cyberespionage tools are known to have used it:

KinS
Microcin
NetTraveler
Enfal (Zero.T loader);
Shamoon
Triton (Fibbit)
Zberp
ZeusVM

There are some advantages for its use in the cases of malware:

data (and the actual data transfer) can be better concealed
makes Anti-malware tools useless against such technique
bypasses Deep packet inspection (DPI)
can bypass Anti-Advanced Persistent Threat (AAPT) measures
steganography detection programs are today at a state of proof-of-concept having no practical reliability whatsoever

So basically, for deploying data to be used later, steganography is an excellent way to do it and in the specific case of malware and data retrieving advanced systems like KATA (Kaspersky Lab’s Anti-Targeted Attack) will only be able to help when something already bad starts to happen.

From a more peaceful perspective, I could just use images for password storage and no-one would never know and I did implement such a solution in practice. Imagine a standard password. Each character of it has a hex value. A bitmap's pixel values also have a hex value. With a very easy to construct program, you can store your password inside a bitmap by altering specific pixels with close values to your password's hex with the actual password character value. If the picture is unique (aka not from the internet so there's a comparison possibility) there is no way whatsoever to determine if a pixed has the original color code or it's something altered.


how to investigate diff between theguardian.com and tehguardian.com

How can I investigate the maliciousness, if any?

It is not malicious, the tehguardian.com can be considered as a parody of the guardian.com.

  They display the same content.

If you look very closely you will see the are not identical.

Some Background

The Guardian Newspaper is well known for containing for containing spelling mistakes and grammatical errors - it had the nickname The Grauniad as a result:

  Deliberate misspelling of Guardian, coined by the UK satirical magazine Private Eye. Refers to the fact that in earlier years the Guardian newspaper was well-known for typographical errors.

Someone (stef) then thought it would be funny to produce a spoof website that was a copy of the The Guardian website but with deliberately inserted mistakes.

  I’ve made a little hack called TehGuardian.com — it inserts random
  grammar and punctuation mistakes into TheGuardian.com. Can you spot
  the mistakes?

  You may remember that in 2013 The Guardian rebranded online as The
  Guardian. No, I thought it was a bit odd too. Something to do with
  guardian.co.uk changing to theguardian.com

  Now, if you saw that happening, what would your immediate reaction be?

  Of course. Same here. I went to my usual domain registrar site, and
  whacked in thegrauniad.com but obviously they’d thought of that.

  So I typed in “tehguardian.com”, “teh” being the proper way to spell
  “the” on the internet, and gosh. Would you look at that? Somehow
  nobody had thought to buy it. And I use one of those one-click domain
  registrars. And I was feeling mischevious. And…

  ...

  TehGuardian.com

  It’s the Guardian website as we know and love. But every single
  article page has up to five grammatical errors introduced into it.

  So if you make the mistake of typing in “teh” instead of “the” when
  you try to reach the Guardian, you’ll also receive a slightly glitchy
  version back.

  It’s quite subtle. Probably my subtlest hack yet.

  Every article that you read via tehguardian.com is exactly the same as
  an article on theguardian.com except that I have introduced incorrect
  Oxford commas, instances of “s’s” where it should be “s’”, swapped
  “they’re” for “their” and a handful of other grammar-pedant-traps.

Source Teh Guardian FTW!!!1!


Cryptography that looks like ordinary email

Say what you actually want to do is to make your encrypted email look like spam. OK, how to accomplish that?

One possible way would be to take the ciphertext and break it down into managable chunks of, say, nine bits each. Using a set of dictionaries, these nine-bit quantities are mapped to one or more words in a target language (nine bits would require a dictionary of 512 words, which is feasible while at the same time providing variation). A Markov chain could possibly be used to pick the next dictionary based on the word selected in the previous dictionary, which likely could be made to make the output resemble very poorly written text in the given language.

By tweaking the interaction between the two parts, the output of such a scheme could conceivably be anything from nonsense to semi-legible text (much like a lot of spam emails). And it'll be text, not binary data.

An even simpler variant would be to simply encode the ciphertext using something like the PGP word list. The result of that will of course be complete and utter nonsense, but it'll probably pass the most simple statistical tests for a given target language.

Now that I've described these ideas, they are of course totally useless. You'll have to come up with something of your own. ;-)


How to make sure the GPG's home directory is safe?

First of all, your private key is usually encrypted, with a key derived from a passphrase (this is the passphrase you need to enter any time you want to decrypt or sign a message). The key generation from the passphrase isn't the greatest (it's an old algorithm) so you need to use a really good passphrase if you're worried about the key being stolen. You'll probably want to revoke any key that might be stolen anyhow, as quickly as possible.
With that said: GPG doesn't actually have to store the keyring in your home directory. That's the default, but you can specify an alternate location when running the program or in the config file (see the --keyring. --no-default-keyring, --secret-keyring, and --primary-keyring options in the manual). You can also just replace the GPG files with symbolic links to files elsewhere, for example on a flashdrive; then only insert the drive (or otherwise make the files available) when you intend to use them. Symlinks only need to be valid while in use; the rest of the time they can point to a non-existent path.
For that matter, GPG has the ability to store keys on a hardware security module. This is almost certainly the most secure option. There are various models available, most of which are either designed for permanent installation in a computer or connect via USB (some, like smart cards, require a special reader). A common - but not the only - choice for a USB removable security module are the various generations of Yubikey, which can store your GPG keys more securely than putting them on a simple flashdrive, and you can make GPG use those keys.
Finally, though, consider your threat model. If you're worried about a program that might have read access to your home directory, it must be either running as you or as super-user (root/Administrator) and either way it has other ways to compromise you. It could alter your PATH environment variable so that the "gpg" program points to a malicious script that steals your passphrase, and possibly also the contents of every encrypted message, in addition to your key files. There are other, potentially less-obvious, ways that it could steal the secrets too. The point being, once something malicious on your PC can read your ~/.gnupg directory, you have bigger problems than whether it can just read the files therein and whether your passphrase is good enough. If your threat model includes offline attacks - somebody stealing your whole PC and removing its hard disk, for example - then encryption is your best protection (after as much physical security as is practical), and rather than rely exclusively on the private key's passphrase, you should just encrypt the whole /home directory and possibly everything except the boot partition, with a strong passphrase and/or additional protections such as USB devices, TPM, etc.


How to use another SSL certificate for DHE-RSA while I already have one with domain?

The root of the problem is that your pi web server is running behind a NAT firewall.  Therefore, it is impossible (without port forwarding) for outside users to connect to your pi web server through the firewall.
Dataplicity's solution solves this problem using a proxy server of sorts.  If you look at the diagram at https://docs.dataplicity.com/docs/how-it-works, your pi first connects to Dataplicity's server (the NAT firewall allows this, because it's an outgoing connection).  Then outside users connect to Dataplicity's server, which then forwards their requests to your pi web server, and forwards the responses from the pi web server back to the users.  But, because outside users are connecting to Dataplicity's server (at *.dataplicity.io), the certificate that they see is for *.dataplicity.io.  This also means that *.dataplicity.io is able to access (and modify) the plaintext of the requests and responses as the are relayed to and from your pi web server.  They are essentially a man-in-the-middle.
A solution to this problem is to setup a public facing server (it can be a VPS).  Then, from the pi, create an ssh tunnel between the pi and the public server, such that incoming https connections to port 443 on the public server are forwarded back to the pi.  Then, point the A record for your FQDN to the public server, and go ahead and create your RSA keys on the pi, create a CSR for the FQDN (containing the RSA public key), get it signed by a CA, and configure the web server on the pi to use the cert and the private RSA key for TLS.  Then when a user points their browser to FQDN, they'll in fact be connecting to the pi (through the public server).  The certificate that the user sees will be the one that you created for your FQDN, and the TLS connection will be established using this certificate and the underlying RSA keys that you've created on the pi.  Then, all the public servers sees is the encrypted traffic passing through it.  If you specifically want the pi server to only allow TLS_ECDHE_RSA cipher suites, you can specify this in the web server configuration on the pi.


Is there a difference between the various certificate templates in windows server?

The templates include, among other things, a list of Key Usage (KU) and Extended Key Usage (EKU) fields that you would like in the issued certificate. Outside of very specific Microsoft services, the template field itself is not checked when evaluating a certificate (it is a Microsoft-only field, not a standard), but basically every PKI application will use the KU and EKU fields and in fact must.

Check with the application (e.g, NPS) which KU and EKU parameters it will accept in the resulting certificate. A lot of the certificate templates basically issue Server Authentication EKU certificates making them largely equivalent, but it's still useful to use the right certificate templates for a few reasons:

It makes it easier to determine why that certificate was issued
and which component may be using it
You can lock down the permissions so that only a few people can issue very privileged certificates
You can issue and revoke certificates for each service instead of for the entire server/device

There are downsides though, including trying to force particular services to only use their specific (template) certificate when multiple certificates are installed on the same Windows server. If you're only really trying to provide simple connection security, then re-using one certificate for multiple purposes may not be an issue.


Is the JDK standard EC KeyPairGenerator suitable for use with both ECDSA and ECDH algorithms?

Oracle Java documentation is a little sparse on the topic, but it does look like with the SunJCE, a key generated asEC can be used with either ECDH or ECDSA. (source):

(I'm not an Elliptic curve expert, but) Theoretically, I believe that the domain parameters for ECDH and ECDSA have the same form, that is the equation of the curve and a base point G

(CURVE, G)

(You'll often see the expanded form

(p, a, b, G, n, h)

where p, a, b are the equation of the curve, and n, h are values derived from G, provided to save computation)

And the keypairs for both algorithms are the same, namely:

priv_key: an integer d in [1, n-1]
pub_key: a point on the curve Q = (x,y) = d*G

Bottom line: Yes, keys are interchangeable between ECDH and ECDSA. Having dug through the Oracle documentation, I'm too lazy to go through Bouncy Castle too, but I would assume that EC, ECDH and ECDSA are all aliases to the same thing, put there to avoid confusion.


Do Linux desktop environments add security risks?

The key question is what untrusted inputs they process and how different the processing is.

Window managers do process icons and titles. Most of the time, they are trusted (they come from apps running with the same privileges), but – for example – some webpage might try to set a very long title, causing a bufferr overflow in the window manager. I believe that such threats are usually minor.

But desktop environment is not just window manager. It might use even a file indexer. I've recently seen an attack technique where a webpage causes a file download (Chrome saves such files by default) and exploits indexing engine. Because it can parse various types of files, attacker might have a large number of potentially vulnerable libraries to attack.

Desktop environment can also contains some widgets and utilities that download some data (e.g. weather forecast) over the Internet. Those are also somehow exposed to attackers.

If you are concerned about local security, you might want to compare screenlocks. However, screen locks work against less sophisticated attacks only.

To sum it up: When you are using traditional distros, there probably will not be significant differences, especially if you turn file indexing (if there is some present) off. Unless you use some totally bad desktop environment. However, if you are interested in securing your desktop OS, you might want to look at QubesOS. but this goes far beyond your original question.


How can systems recognize different wifi AP with the same SSID and MAC address

It's the Security parameter.

From experience, if you make the rogue AP's security protocol  as same as the real AP with the same key, the clients will connect to the rogue AP when the real AP shuts down.


Random pop ups caused by add on in Firefox

You can fix this. You can stop the popups, if you don't like them. Its Open Source!

As you can see the source of the addon here . There are couple of lines on the top in bootstrap.js file.

    firstRunURL:'http://barisderin.com/?p=2262',
    updateURL:'http://barisderin.com/?p=2264',

Simply change them to ,

    firstRunURL:'',
    updateURL:'',

Additionally, the popup is caused by line-276

FacebookMessageSeenDisable.openURLInTab(window,facebookmessageseendisableUrl);

Just comment out this line using //.

Above changes can be implemented in practice as follows.

Download the xpi file from here using chrome/ie/Download manager.
Open the xpi file with a Archiver like winzip/winrar/7zip.
Edit the bootstrap.js from the archiver with above changes  and save it.
Once you save the bootstrap.js file, archiver will ask whether to update the archive with changes. Choose Yes. Now the .xpi archive is updated and saved.
Go to Firefox, Choose File->Open File from menu. Select the updated xpi file and install it.

Note: Also I did these changes and you can download from here . Replace already existing one with this. And those popups should be gone now!


There is no evidence here that the machine was compromised.

This is your web browser accessing some pages that had exploits on, and consequently saving them to the standard browser cache. The AV caught and prevented the file storage, generating the alerts in the process.

The thing is, these alerts, and indeed the AV behaviour in general, are pretty useless:

If your browser and any web-visible plugins are up-to-date and not susceptible to the exploits in question, you weren't in any danger in the first place.
If your browser or plugins were susceptible to the exploits, you got compromised regardless of the AV blocking storage to the cache.

(Chances are that even if you were vulnerable in principle, the exploits probably only had payloads targeting Windows. There are cross-platform sploits, usually based on platform-independent plugin weaknesses, but they're not yet that common.)

So, yeah, I wouldn't re-install based only on the evidence above. But no-one can guarantee that you weren't compromised by something else that the AV didn't detect. AV is of diminishing reliability today and is wrong as often as it's right.


Ensuring that non-executable files are not malicious

There is a new and growing technology area called Content Disarm and Reconstruction (CDR). This does what you are asking for in general, however not all CDR solutions tackle all file types (like audio and video).
The idea is that the file is analysed and reconstructed to contain only the data and format, but nothing else. It's like a sanitised copy of the file.
I predict that CDR will become an important part of everyday security, but it is still in the "new and cutting edge" phase right now.
In the absence of a tool, you are looking to perform the same function on your own. How that works will depend entirely on the file type and what you need to extract. To do it safely, you can take the same approach as CDR tools: sandboxes and disposable VMs in case the malicious code was destined for your tools.
(full disclosure: I advise a CDR company)


Why are there no browser feature or extension to only check the domain and username to prevent phishing?

There are and you mentioned one: favourites. Favourite or bookmarks do exactly what you want. But I suppose that you feel that there is a problem with that as a solution, and there is.

The problem has to do with the balance of security and convenience. You want something that is effective but does not reduce your ability to do what you want. A solution has to provide clear information, but not be in the way. You would quickly uninstall a plugin that showed a banner on every website that was not in your trusted list. You also do not want something that the user will easily overlook. So it has to be out of the way until it becomes relevant. Knowing when to be relevant is a massive problem to solve.

Here is what has been tried and is available even today:

Before password managers, the advice was to bookmark the sites you went to and to check for the star before you entered a password. This was about as successful as you would imagine (not very). It required that people voluntarily remembered to check before entering passwords.

Browsers themselves had built-in tools, like IE's "Trusted Sites" list. It displayed an icon in the bar. But that had the same problem: it required that users check for the icon.

Then there came cookies that allowed you to remain logged in so that you never had to type in your password ("keep me logged in"). If you had to log in, something was suspicious. This became a massive vulnerability because cookies could be stolen.

TLS certificates used to be expensive so the advice for a long time was "if you see the green lock in the URL bar, then you know it is trusted". This was fine until certificates became free and, like favourites, it required the user to voluntarily check for the lock. Malicious actors would also leverage valid sites using TLS to host their malicious pages (or use Google Docs).

Then, in the corporate environment, there were whitelists. This was extremely successful to prevent phishing, but awful in terms of employee happiness. You can still get browser extensions that use the whitelist idea.

Then there were the "reputation circles" and other reputation-based methods. A browser extension allowed users from around the world to rate sites. This was much better than whitelisting, but then malicious actors poisoned the ranking system and allowed malicious sites to be trusted.

To improve on that, DNS services used their info to provide reputation services, and there are many used today. You can get these DNS reputation plugins for any browser. The problem here is that it is up to the DNS provider to recognize and rate a site appropriately. Malicious actors are actively finding ways to evade their algorithms.

Password manager plug-ins are the best way to protect yourself from this problem, and it is not a "hack" but a defined feature of browser-based password managers. You set a password that you cannot remember yourself, you get the password manager to do it for you, and if it doesn't, you do not just know that something is wrong, but you are prevented from entering the data that you do not know. Offline password managers cannot do this for you.

An online, in-browser password manager is completely out of the way until the very point where it is needed. It is unobtrusive, and provides a barrier that is difficult to get past without a lot of effort. It defines the list of relevant, trusted sites, and offers both convenience and security. That's why they are so highly recommended, especially for non-technical users.


A session has presence both on the client and on the server:

On the client, the session identifier is stored in a cookie with a limited lifespan.
On the server, the session is stored somewhere and typically also has an expiration date.

Logout functionality needs to handle both: remove the cookie from the client and terminate the session on the server. The latter is most important, or else the session remains valid even though the client no longer has the cookie. This seems not to happen in your case. Ask the developers to terminate the session on the server when a user logs out.

  Without logging in, I tried to access a URL that lies behind the login, but I sent that HTTP request with the cookie that I had noted down before logging out.

So you logged out and could still access a page for which you should be authenticated. This means that on logout the session is not terminated, which it should.

  Later, I tried the same URL with the same cookie, but after the expiry time of the cookie and as expected, the URL threw a 403 forbidden error.

This means that the session has expired on the server. The sessions on the server have a limited lifetime, which is good. This could be the same duration as the cookie expiration time, but it doesn't have to be.

  Or should I ask the app owners to destroy the cookie as soon as the user logs out regardless of cookie's expiry date?

Yes, this is reasonable to ask.


If hackers know my android app license key , can they redirect the in app purchases of my app to their account?

Knowing your app key doesn't give any control over your developer account or payments, it is supposed to identify the app, AFAICT.

Also, XOR encryption in app code is merely obfuscation, a poor form of DRM.

If they can extract the key, they might also be able to locally manipulate the app to bypass restrictions on paid features.


Does Windows "System Volume Information" folder pose a security risk in servers?

This is an old question, but a few points have been left out of the other answers.

First, to directly answer the question, yes, the System Volume Information folder can contain sensitive data. As Sorcha described, DFS in particular will store files there by default, but so will many other system services and applications. VSS, System Restore, etc as mentioned by dandavis. Most of these applications and services store their data on the System volume (C) or on the volume being backed up by VSS, so your exposure from the System Volume Information folder on volume G is limited to the data on volume G, though most of this can be configured away from the defaults.

However, there's more going on here than just the potential security risk of the System Volume Information folder.

Having Directory Listing enabled on Apache is a security risk.
Pointing Apache to the root of your volume is a security risk.

From this perspective, you're essentially expressing concern that someone might snoop around the contents of your closet when you've left your front door open. You can put a lock on the closet, but maybe you should just shut and lock the front door?

On a side note, I'm going to add that it sounds like you're using typical *nix practices, like splitting your website into multiple partitions, in a Windows environment. Windows is great if you need your server to do more than one thing, to integrate with other servers that do more than one thing, or to host a .NET website. If all you're running is Apache web server, you'll find nearly any flavor of *nix to be more secure and better performing.


Best efficient windows hardening audit script

No, not really. A script really doesn't have enough reach within a Windows environment to get all of the information you would need. PowerShell might be able to do it, but I would be surprised if such a script exists. +1 if there really is one.

With that being said, your best bet may be the Baseline Security Analyzer by Microsoft: http://technet.microsoft.com/en-us/security/cc184923. The nice thing about it is that it can be scripted, however parts of it need to be installed on the workstation.


Is there a way to attack STARTTLS + certificate pinning probed from multiple places?

What attacks do you want to prevent? If a malicious system administrator (or anybody/any agency forcing him to be one) is contained in the list, you're out of luck without end-to-end encryption, no matter what fancy validation schemes you apply.

Regarding your approach: as I understand, it is absed on the idea that nobody will be able to control different routes from different countries (out of different Tor exit nodes) to the other mail server. This is not necessary for an attacker -- he only needs to be in control of the other mail server's uplink to be man in the middle to all those verifications at once.


Detecting a keylogger based on its periodicity seems like a strange way of doing it and using a random timer to thwart that detection seems strange as well.  If I was writing a keylogger, it seems more natural to implement something like once the logfile reaches a certain size (say 50 kB), start a new one and transfer the old file, versus sending on a fixed tmier.  There are plenty of data transfers that should occur at periodic intervals, so the mere fact that a transfer is periodic doesn't indicate much (e.g., backups to a local NAS, checking for updates, requests to fetch mail, etc.)

Really, the best way to detect is that unrequested network connections are being established by processes you are not using (e.g., in linux look at lsof -i -n or netstat -p -n -t) or haven't authorized.  You can also use a tool like nethogs which will actively collect statistics on how much network activity each process uses.


Every permission needs to be declared in the AndriodManifest.xml before an app can use them. For example:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android.app.myapp" >
    <uses-permission android:name="android.permission.RECEIVE_SMS" />
    ...
</manifest>

to be able to receive SMS.

This manifest will also be used to list the permissions shown when you download the app in the store.


Do I run the risk of not being anonymous with this setup?

Browser fingerprints always work. You can make them much less effective by disabling Javascript etc, but you can't keep a server from fingerprinting the browser (and the device and operating system) based on the HTTP headers that get sent to the server.

The point of using Tails would be that everybody who uses it shares the same browser fingerprint, so it can't be used to uniquely identify you. But running Tails will make you stand out as a Tails user.

Running Tails inside a VM adds a layer of security in case your instance of Tails is hacked (possibly through a browser weakness) - so it will keep the files you store on the hard drive of your computer/laptop out of reach of an attacker, but it won't make a difference if you're just interested in not providing information about your device to a server (eg GMail).

https://panopticlick.eff.org/ has a nice service to measure how unique you are based on your setup.


When you see multiple HTTP request on the same TCP segment, in general this is called 'HTTP pipelining'

By using pipelining, you can put multiple methods on one request from the client side: https://en.wikipedia.org/wiki/HTTP_pipelining


The short answer is yes, but it's more difficult.

The main principle of using VLANs to segregate the PCI DSS environments is reducing scope for assessment and maintenance. If you reduce the scope, then only the servers which need to be compliant are assessed.

If you don't segregate, then the rest of your network (and all the users of those devices) come under scope, too. It's not impossible, but it does complicate matters a lot more than simply configuring VLANs on you network.


Security risks by hosting a Nextcloud on home PC via virtual server

When you say, tunneling traffic using 6tunnel, you are considering security in transit while when you mentioned use of virtual server, you are considering seclusion of private system and server so private data is considered safe.The hardware to serve both remains the same.

The risk you are not considering is comprise of web app/site and the moment control is gained, attacker will know very easily that the system is hosted on which virtualization technology and try to bypass it to gain hold of underlying system via local network or bypassing virtualization layer. These attacks are not theoretical. Even when you consider hosting your site on docker, you need to take care to make docker secure enough before hosting it on internet. A good amount of administration and care is needed to take such calculated risk.

I can only talk about security threats and have little to no idea about which country you belong to, what ISP are you using and what conditions shall be considered for commenting on breach of use with ISP. I request you to consider doing your risk assessment thoroughly again.


Web Hosting companies asking for password in plain text

Being slightly in the hosting business I realize what you mean. To put it simply, it is extremely bad practice to ask clients to give their passwords in plain text but all companies do it. They either ask the full password or simply a few characters from the end.

My point is that, at some places like dedicated servers it's impossible to provide support without asking for the admin/root password in many cases, then again for shared servers the support should able to get right in with their own accounts.

I'm assuming at the least that he used your password to compare it to a stored hash, but security procedures can be flawed in many such hosting companies. I say this definitively because I know that cPanel, Plesk, etc do not store passwords in plain text, therefore he'd have no way to just "read" it.

You should however change your credentials every time you contact support. You should also write about this on an open forum so that the host takes a good initiative to prevent such malpractices as they can easily use a secondary question answer or a phone call, etc to verify one's identity.


Privacy: can my employer access sensitive information if they pay my mobile subscription? I bought the hardware myself

They will most likely be able to see an itemised bill showing who you called and when. They will also be able to see mobile data usage.

If the phone is enrolled in the organisations mobile management system, they may be able to monitor and control app usage as well as monitor and control internet traffic.

UPDATE: In a worst case scenario they could potentially install full monitoring and install things like key loggers, this is very unlikely however. Additionally, depending on what part of the world you live in, there are restrictions on what they can legally collect, especially without consent.

The best thing to do is ask your company what you can and can’t use the phone for. If it is a large organisation they should have a security policy and an acceptable use policy.


Understanding a real stack based based buffer overflow

From the wiki article you linked:

  The code appears to safely perform bounds checking because it checks the size of the variable length, which it later uses to control the amount of data copied by png_crc_read(). However, immediately before it tests length, the code performs a check on png_ptr->mode, and if this check fails a warning is issued and processing continues. Because length is tested in an else if block, length would not be tested if the first check fails, and is used blindly in the call to png_crc_read(), potentially allowing a stack buffer overflow.

The code appears to check if the length is shorter than the buffer. But the length checking is done in an else if block. When png_ptr->mode & PNG_HAVE_PLTE is false, a warning is logged and program execution continues without performing the else branch and thus without checking length > (png_uint_32)png_ptr->num_palette. That means in any situation where the "Missing PLTE before tRNS" warning is generated, the length is passed to png_crc_read without ever being checked.

A plausible explanation for how this bug could have been introduced is that "Missing PLTE before tRNS" used to be an error-condition which aborted the whole function. In that case there was no reason to bother what would happen afterwards. But some time later someone reduced it to a warning-condition without checking what that meant for any subsequent code.

Edit: Another possibility for a buffer overflow in the above code could be if the value of png_ptr->num_palette comes from an untrustworthy source. But the example doesn't mention where it comes from, so I doubt that's what this example wants to illustrate.


How to avoid response manipulation in NodeJS Application?

This is a standard man-in-the-middle attack. You protect against it by using HTTPS. That adds encryption (confidentiality), tampering protection (integrity), and authentication. You'll need a TLS server cert installed in Node.


Yes, it's safer

If you mean safe in the general case ("can they introduce a boot time backdoor or format my hard drive"), then yes, using a standard account is much safer.

With an administrator account, you might not install software, but as soon as some attacker manages to use a Chrome weakness to run some arbitrary software on your PC, you're done for.

It does not matter how safe Chrome is. There have been attack vectors like images libraries - they could get in (and did so, in the past) simply by placing a prepared GIF/PNG on some harmless website. They could exploit some fancy Chrome bug and install some plugin which you notice only when it's too late.

No, it's not safer

If you mean "safe" as in specifically "can they get my data, impersonate me or empty my bank account, make me take part in DDOS attacks" and so on, then no. If you are the only user of the machine anyways, and do everything from your one unprivileged account, then they can pretty much do to you whatever they could if you had admin access. They just can't harm the system itself or other users on that machine (in this scenario, there are none).

It will still make it a little harder (they will have a hard time overriding security prompts by whatever software you are using, and so on), but generally possible.

So...

The benefit of using a standard account is that you do other stuff in other accounts. I.e., if you do general web browsing, you do that on another account than your online banking (depending on your level of paranoia). If you have wife and kids, they use different standard accounts. If you have an antivirus or a local firewall, you configure them from the admin account and not your personal one. And so on.


How link flooding DDoS attack remain undetected?

...I want to know how link flooding DDoS attack works...

The authors of the second paper  (SPIFFY) provide two references in the first sentence of the introduction: The Coremelt Attack and The Crossfire Attack. From reading the abstract and introduction of these papers it looks like the basic idea is that a selected network path is saturated with large amounts of normal traffic. The source of this traffic is an attacker controlled botnet and the many targets are either from a botnet too or just normal public servers. Due to saturation of this link any connectivity over this link is negatively affected, i.e. a denial of service.

  ... how to remain undetected?

Given that this is normal traffic (i.e. HTTP or similar) between many sources and many targets it does not look like the typical DDoS which is directed against one or a few systems. Instead it looks like normal traffic and thus existing DDoS detection heuristics don't get triggered.


Are all SSL/TLS implementations vulnerable to the Heartbleed bug?

If you look at the Heartbleed summary:

  The Heartbleed Bug is a serious vulnerability in the popular OpenSSL
  cryptographic software library. This weakness allows stealing the
  information protected, under normal conditions, by the SSL/TLS
  encryption used to secure the Internet. SSL/TLS provides communication
  security and privacy over the Internet for applications such as web,
  email, instant messaging (IM) and some virtual private networks
  (VPNs).

  The Heartbleed bug allows anyone on the Internet to read the memory of
  the systems protected by the vulnerable versions of the OpenSSL
  software. This compromises the secret keys used to identify the
  service providers and to encrypt the traffic, the names and passwords
  of the users and the actual content. This allows attackers to
  eavesdrop on communications, steal data directly from the services and
  users and to impersonate services and users.

You asked:

  Does it mean that Heartbleed bug would change the degree of promise
  toward SSL/TLS ?

No it doesn't. You can see it's specifically about openssl. Heartbleed was a software bug, a  programing error. It was not a weakness in the SSL/TLS protocol itself, like for instance CRIME or BEAST.  The important lesson we learned from Heartbleed is that code should be reviewed prior to its usage. The memory leak in OpenSSL was a significant  one, but programing errors exist and will exist in the future. All we can do is perform regular code reviews and simplify/clean code (OpenSSL is a bit of a mess).

The other libraries (actually any piece of software for that matter) could have easily had one as well, the main threat here is human error, which is sometimes hard to mitigate.


It looks like you want to achieve re-authentication of a user before an account linking/unlinking operation.
In your example a user would be authenticated with her Facebook login at an application. When the user (or attacker) tries to link a second social login the application would request re-authentication from Facebook. It is described here: https://developers.facebook.com/docs/facebook-login/reauthentication/
After re-authentication the app can start the account linking  process.


It is highly unlikely that the YouTube app resulted in a compromise. Not only would an attacker have to have XSS on the youtube browser container, they would then have to break out of the app sandbox, and then root the system - which requires a minimum of three exploits. The Google Bug Bounty Program pays out for these kinds bugs, although XSS has been found in youtube before, an attacker will make more money reporting this kind of bug to Google than compromising an old tablet.

YouTube is a service, and is not eligible for CVEs.  Google has no obligations to make public the details of patched vulnerabilities.

Yelling at your friends it not a security measure,  if you are interested in keeping your systems protected - then they must be regularly updated.  If chrome and android haven't received updates, then any website you visit could result in a remote jailbreak - which requires one less exploit. In context, Stackoverflow is far more dangerous than Youtube because google has more money to spend on security.


Based on the information that you've provided and your comments, I'd guess your problem is one of the following (arranged in decreasing probability):

Your D:/ Drive contains malware - You mention that there is nothing of value in that partition, but you've not wiped it since the day you got it from the factory. Some systems come with auto backup software that backs up to that disk, and I'd guess that your previous OS backed up an infected file which is again working its magic.
Infected reinstall media - You're using a backdoored image or it was tampered with after you created it.
Bootsector virus - As Hacktiker said, but less common and less probable.


I'm guessing you are trying to brute force a login form, sometimes with hydra cli you have to play with it editing number of threads, etc. Here is a good tutorial which explains all the GET/POST methods as well as using hydra on brute forcing and launching a dictionary attack.

Also you need to supply good password / bad password condition which are called tokens like ^USER^ and ^PASS^ in the URL where they are to be replaced by the usernames and passwords under test. The second is done by hydra by string matching against the returned page. You can either test for a failure condition, such as "Bad password", or a success condition, such as "logged in". If you don't supply the conditions how does hydra know what username:password combination is the correct one? You need to let hydra know what it means to login successfully and unsuccessfully, each website is different like "Bad Password" "Login Incorrect "Please Try Again".
Here's a very simple command line example:

hydra 127.0.0.1 http-form-get '/login.php?username=^USER^&password=^PASS^:Bad password'

Hydra Guide

PS: Also sometimes due to high number of threads the page doesn't have time to load giving you false positives always try to decrease thread count.


Malewarebytes Business for Personal Use Question

I cannot address comparison of specific products on this StackExchange.

However, I do have a bit of experience with the product you mention, and it comes with a warning.

From experience:

Malwarebytes works as advertised but is is famous for urging you to use BoostSpeed.  It tries to install it by default.  It is a bit nagging.

As for your question, there is likely no difference other than that the university is paying them for non-personal use.

I would bet that it is the same program either way.

Here's the warning:

Be aware that BoostSpeed also installs Geek Buddy, which opens up your PC to remote-control from outside.

I have tested BoostSpeed enough to know that it hasn't made any visible difference in the speed of my computers.

-->  If you get BoostSpeed installed, try it, then change your mind, be sure to uninstall both BoostSpeed and Geek Buddy or you will still be open for remote control from the outside.


How safe is it to install XAMPP on my home computer to test PHP code?

Apache and MySQL can be configured so that they only listen to requests from your own computer. For most test systems this is fine and it greatly reduces the risk because  the services are not reachable from the Internet.

Before you start XAMPP for the first time find and edit these files:

For Apache edit the files xampp\apache\conf\httpd.conf and xampp\apache\conf\extra\httpd-ssl.conf. Look for lines starting with "Listen" such as

Listen 80

and replace them with

Listen 127.0.0.1:80

For MySQL open the file xampp\mysql\bin\my.cnf find the section "[mysqld]" and add this line

bind-address=localhost

After starting the services, verify the result by going to a command window and start and execute:

netstat -a -n

For the entries marked as LISTEN in the last column, look at the Listen column. It should always start with 127.0.0.1 or ::1 but not with 0.0.0.0.


Ultimately, if the machine can use the saved password without specific human intervention, then... it can use it. This means that an attacker who gains full control of the machine (either an hostile software hijack with Administrator/root privileges, or he grabs the laptop and runs for it) will be able to recover the password. On a theoretical basis, if you want to resist such an attacker, then you need the password to never make it to the machine RAM itself; you need some tamper-resistant component which does all the processing. This is the model of smart cards and payment terminals, which have physical shielding and actively destroy sensitive data in case of physical breach; and they have no notion of "root user" accessible to the actual human user either.

At best you can hope to slow the attacker down. Yet, there still are management methods which are better than others. For instance, when you store some sensitive secret value, you want to avoid letting leak to the backups, or at least with some specific protection. Similarly, the user may want to integrate such storage within a bigger secret management solution, e.g. a "password safe" with a master password, or things like that. Your best bet, then, it to rely on OS-provided services for storage of sensitive data. On Windows systems, this points to DPAPI. On Mac OS X, use Keychain. As usual, the software which is easiest to design and implement and deploy is software which has already been designed, implemented and deployed by somebody else. Thus, don't try to do more or less smart things on your side; just let the OS do its work.


Have firewall and VPN already, should I buy a mini router to protect my laptop?

A small router would help isolate your device from the hotel network, relatedly it would reduce your wireless exposure, assuming you turn Wi-Fi off on your computer as you are using the router.

You may conflict with the hotel network if you misconfigure the router, this may cause them to dislike you and possibly, disconnect your networking.

You may also find that ensuring your computer firewall is properly configured is as effective and less hassle, than carrying a router and peripherals.


Technically speaking, you are correct. Your Facebook data isn't encrypted and can be read by anyone with direct access to Facebook's database infrastructure.

Facebook's Data Use Policy, emphasis my own.

  We use the information we receive about you in connection with the services and features we provide to you and other users like your friends, our partners, the advertisers that purchase ads on the site, and the developers that build the games, applications, and websites you use. For example, in addition to helping people see and find things that you do and share, we may use the information we receive about you:
  as part of our efforts to keep Facebook products, services and integrations safe and secure;
  to protect Facebook's or others' rights or property;
  to provide you with location features and services, like telling you and your friends when something is going on nearby;
  to measure or understand the effectiveness of ads you and others see, including to deliver relevant ads to you:

  to make suggestions to you and other users on Facebook, such as: suggesting that your friend use our contact importer because you found friends using it, suggesting that another user add you as a friend because the user imported the same email address as you did, or suggesting that your friend tag you in a picture they have uploaded with you in it; and
  for internal operations, including troubleshooting, data analysis, testing, research and service improvement.

IANAL, but the bolded part suggest that by using Facebook, you are giving Facebook permission to analyze  your information.

It is very likely though that Facebook has internal policies regarding staff access to such information. Also, given the sheer size of Facebook's data, it is unlikely that a human employee will sit at a desk and read your personal information. Any analysis done by Facebook will most likely be done by computers and algorithms.


Cloud aside, if Ansible becomes compromised, then it exposes all the servers it manages.

The question becomes: how best to mitigate that risk.

If you use your laptop, then anything you do on the laptop potentially exposes Ansible. Browsing, installing, etc. A dedicated, locked down image that is not used for personal activity is better, in that regard.

Ansible puts all your eggs into one basket and then, to quote Andrew Carnegie, "watch that basket!"