Exchanging private keys I would like to understand something about security. Say two parties have a private piece of data (e.g. a password or license key) and the receiver needs to know that the sender has the same key and they can only exchange information over a public connection.

I can think of two ways this can be accomplished which seem secure to me:

The receiver send the sender a random text string. The sender concatenates this string with his private data and sends the SHA1 back. The receiver then does the same and compares the results;
The sender creates a random text string, concatenates it with the private data and sends both the random text string and the SHA1 of the concatenation to the receiver.

The only thing wrong with the second one is that the receiver doesn't have control over how random the salt is and would need to implement a system to ensure that it's random.

I know security is very tricky, so I would like to understand what is wrong with the above scenarios.

The first thing to define is the context. Usually, proving knowledge of a shared password is called authentication. It really makes sense only if linked to some other data. Imagine that the two involved parties (let's call them Andrew and Betty) run the protocol over a TCP connection, or something HTTP-based, or whatever. Andrew wants to prove to Betty that he knows the password; assume that he just did; then what ? At that point, Betty is possibly convinced that Andrew has been involved. But if some data comes just after that exchange over the same connection, then Betty cannot be sure that the data is really from Andrew. An evil attacker (Carter) could hijack the connection in some way, just after the exchange: that's possible, since we assumed that the protocol was done over an unprotected TCP connection, or any similarly insecure transport medium. There are several flavours for such hijacking, e.g. Man-in-the-Middle.

So the authentication makes sense only if it can be somehow be tied to subsequently exchanged data, in a cryptographically strong way. There are two main ways to do that:

Play the authentication protocol within a strong tunnel which guarantees overall integrity, and has already authenticated Betty (i.e. Andrew is sure to be already talking to Betty). That's basically what happens with HTTPS Web sites. Andrew (the client) establishes a secure tunnel with Betty (the server), and Andrew knows that he is talking to the genuine Betty because he validated Betty's certificate. Note that in that scenario, it is not difficult to have a tunnel which also guarantees confidentiality (by encrypting exchanged data), at which point Andrew can simply send the password as-is (it is simpler, and no weaker).
Turn the authentication protocol into a key exchange protocol, in which Andrew and Betty derive from their knowledge of the shared secret P (the password) a common key K, which is then used to build a secure tunnel which guarantees data integrity (and, there again, the tunnel could also provide confidentiality).

Without such a binding between authentication and data, the authentication protocol can achieve anything worthwhile only if it is played in a context where Carter cannot alter the ongoing exchange between Andrew and Betty. We then assume that Carter can spy the messages of Andrew and Betty, and we want to prevent Carter from learning the password, because it would allow him to come back later, as a new protocol instance, under the guise of Andrew. Please note that this is a restrictive scenario, which applies to practical computer-over-network situations only insofar as attackers are lazy and do not build full-scale active attacks (i.e. the attackers are not really motivated, so whatever hides behind the password must not be something valuable like, say, your bank account).

In the passive-only attack scenario, we can say the following about your protocols:

Protocol 1 is a classic challenge-response. The general principle is sound, but there are details in the realization to be taken care of. Namely, if you just use a hash function like SHA-1, then it relies on the hash function to be indistinguishable from a random oracle, a mythical theoretical object. Unfortunately, it is known that SHA-1 is not indistinguishable from a random oracle. The right way to make a challenge-response protocol is to have Andrew compute a Message Authentication Code over the challenge, using the shared secret (password) as key. A standard MAC construction is HMAC, which is itself based upon a hash function (you can use SHA-1 if you wish), but HMAC invokes the underlying hash function twice, in a smart way, so as to avoid the shortcomings of the hash function not being a random oracle.
Protocol 2 is weak because it is susceptible to a replay attack. Carter could record a message sent by Andrew and replay it as is later on. The message is a hash of a combination of a random string chosen by Andrew and the shared secret (it could also be a MAC, as explained above -- it does not change things with regards to replay attacks). Betty accepts that message as a proof. If Carter sent the very same message again, why would Betty reject it ? To make this protocol resistant to replay attacks, Betty must remember past messages, and reject an authentication message which it already got beforehand. Since this may lead to unbounded memory requirements for Betty, you would have to include a time stamp in the random string: Betty would reject any message where the "random string" is "too old". This is tricky to do in practice: keeping two distant computers with synchronized clocks is a hard requirement. Also, one must take into account reboots (if Betty reboots, she looses her RAM contents) and multi-frontend servers (if Betty is two servers, both must share the same memory of already seen authentication messages).
When the shared secret is a password, additional problems rise. A password is the specific kind of shared secret that a human will be able to remember, and accept to type on a keyboard. As such, it cannot be too long or complex, and it is possible for Carter to setup a very long, but not intractably huge, list of potential passwords, and try them all. This is called a dictionary attack. The scariest dictionary attacks are those where Carter can "try" a password by merely computing things on his machines, without interacting any further with Andrew and/or Betty: these are offline dictionary attacks and are deadly because Carter could be a bored student who temporarily "borrows" the computing power of 1000 machines at his university. With your protocols, spying one challenge, and the hash-with-password computed over it, is enough for Carter to do an offline dictionary attack (he just tries potential passwords until he finds one which is consistent with the messages he eavesdropped). Offline dictionary attacks can be partially hindered by using salted, slow hashing like bcrypt or PBKDF2. A more thorough solution is the use of a Password-Authenticated Key Exchange protocol.

Therefore, practically, for authentication, you should either:

Use a secure tunnel (SSL) with an appropriate certificate by one party (the server, aka Betty), and have Andrew send the password within the tunnel "as is". That's how the Web works today. Code is available.
Or use a secure tunnel established over the output of a PAKE protocol: Andrew and Betty run the PAKE protocol, using their shared password, to establish a shared session key, with which the tunnel is integrity-protected and encrypted. There again, this is SSL/TLS, specifically TLS with SRP (GnuTLS is a software library which supports that).

Otherwise, if you are in one of these extremely rare situations where active attackers are not to be feared, or if your hardware is so cheap that it cannot cope with strong protocols anyway (e.g. you are designing a protocol for RFID tags), then you might get away with a challenge-response protocol like your "protocol 1", provided that you use a proper MAC (i.e. HMAC) and take care to use a strong enough password (i.e. a sequence of 12 random characters at least, and not at all a four-digit PIN).


Domain offline - are unmaintained email clients a security risk? I have just unregistered a domain. Now my mail client (Thunderbird) popped up a message saying that it cannot connect to the mail server. That's fine - for the moment.

However, I wonder what would happen when someone else registers the domain. Given the registrant would have an interest in attacking, would it be possible for him to figure out user name and password from a dangling client that repeatedly tries to connect?

Obviously, people would not immediately delete their mailbox locally. Perhaps there are still some mails to be archived or similar.

Is there some kind of "last action" a mail server can send to the client in order to prevent the mail client from connecting to a future server on the same name?

For my mailclient, Thunderbird does not have an option for disabling an account. I can also not delete the server name completely. It wants a valid server name. If nothing is entered, it will automatically choose the old name again.

If you have a domain that has handled important email for you, you need to keep it registered forever or at least until any email you might receive is completely useless.

An attacker can easily buy your old domain, setup a mail server to accept all mail regardless of whether or not the user exists, and accept any mail sent to you.

This means that s/he could send your bank a password reset request for example, accept the email, click on the link and steal your money.

There's no particular risk for your client software. The only risk I can see is that whoever owns the domain can accept and read your incoming mail.


Passwords in memory, practical ways to improve security Storing a password in an application's memory is risky. The OS may write a portion of memory to disk as a swap file. Processes may access each others' memory, even though they shouldn't. (More)

I'm developing a deterministic password generator with Java and I'm wondering what's the best way to handle the master key in memory. There's going to be periods of time where the application needs to "remember" the master key, before it can overwrite it in memory. I thought about encrypting the master key in memory and writing the randomly generated decryption key to disk. When the master key is no longer needed, the app would attempt to overwrite both the file on disk and the encrypted master key. This approach would at least provide some security against someone later uncovering an old swap file. Does it make sense? Should I do something else?

What are good practices to reduce data lifetime of passwords and cryptographic keys in memory?

In Java, it is recommended that a char[] is used for sensitive data instead of a String object. This makes it possible to overwrite the data when done with it, something that is not possible with the immutable String object.


Automated browser-level countermeasures to look-alike login pages For example, say an unsuspecting visitor gets a link security.stackexchange.com/.... Then it re-opens the login page, with or without an explanation as to why they have to log in again. (this is more likely to be a problem for place like Cooking or Music than a community of Security enthusiasts)

At least in StackExchange there is an extra layer of security in that it takes one more click to get to the Google login.

But other services do not have that. These example pages could have been crafted to submit login information to a third party. Then bring up one of Google's better known error pages and re-word it to say that the service is temporarily unavailable, and to please try again in a couple minutes.

A non-techie user is now hacked. Teaching them about these attacks is going to be incomplete.

But what about automatic ways to detect pages like these?

Is there any screen-shot recognition plugin? Or resource recognition? That IT Security logo for example, is a resource. All the resources could be check-summed, and identified to their domain name. I visit this page often, so it is pretty clear that the logo belongs here, and not on any other sites I visit.

This could warn the user of some of the more simply crafted hacks that are still under the radar and not detected & reported yet.

What is there to know on this subject?

There is no protection like that. It's even technically impossible (or very hard) to prevent users from trusting the website looks and believing that the site is known when the URL bar clearly states that they are on a totally different site. This is why phishing is so popular and current browser fight phishing through blacklisting phishing domains using e.g. Google Safebrowsing. But, as every service based on a black list, this does not eliminate the problem.

I don't know any 'resource checksumming' service and I doubt any exists. It's much simpler to just look at the address bar when you're logging in. As an website owner you can also use EV SSL certificate to enhance positive feedback, displaying entity name together with the website address.


Is inputting a password over a phone secure When calling my bank, they require you to input your username and password using the phone keypad. Is this a safe practice? Specifically, is this less secure than inputting my password on their website?

As keypad buttons don't map 1:1 with ASCII characters, a potential eavesdropper wouldn't have my exact password, but would have a significantly reduced guessing space.

Is this a safe practice?

No, absolutely not.

Unlike internet traffic over HTTPS, phone lines are not encrypyted. In theory, nothing is preventing HTTPS-style encryption, but the problem is that both devices need to be able to do that. Normal phones just can't do it. And unlike HTTPS, there is no single big solution that the whole world knows and accepts.

Note that GSM and later mobile phone protocols have some encryption, but a) it is not that secure, and b) in the usual case, the signal to the base station is encrypted, and then from the base station on it's plaintext again.

Also note that some few of the "big" lines between countries etc. are encrypted (ie. phone->telecom1 not encrypted, telecom1->telecom2 encrypted, telcom2->phone not encrypted), but sadly that's rather seldom.

What that means for practice? Either crack GSM, or more easy set up your own base station, or even more easy (but a bit dirty) dig a hole to get to a major transport cable. (Or, if you're a diva like some certain government agency who doesn't want to get dirty, ask the biggest phone/internet node on the continent to get own rooms in the network center.). Being a telecom employee is nice too....

The only positive aspect might be that most attackers focus on the internet and related devices (computers, mobile phones, ...), instead of old phone connections.

  Specifically, is this less secure than inputting my password on their
  website?

Sure

  As keypad buttons don't map 1:1 with ASCII characters

So what? Anyone listening for pressed phone keys knows that and can easily convert it


Is it common for malwares to use public-key cryptography to authenticate their C2 commmunications? I'm sure there are instances of this, but I ask it because malwares are often so makeshift that I could definitely see their authors purposely using weaker forms of authentication to perform communications (or no authentication at all) just for the sake of time or efficiency. I'm wondering what the general trend is in using strong authentication protocols for C2 and if breaking those protocols could be an avenue for disabling malwares.

In 2017, security researchers at Cyren discovered that over 1/3 of malware was using HTTPS for their C2 activities.

"Breaking those protocols" is never the answer, it is equivalent to when Kazakhstan forced a MITM attack on the entire country.


How to lock out login attempts with SQL I don't want by server to get brute forced but I don't want to use a CAPTCHA as they're not user friendly / I don't want to rely on another company - because I'm not going to implement my own captcha system.

I've thought of creating a attempts table with this structure:

________________________________________________________________
|         IP         |      ATTEMPTS      |        LOCK        |
|‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾|
|       1.1.1.1      |         0          |          2         |
|        ....        |        ....        |        ....        |
‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾          Yes I had fun making this

And let the user have 5-10 attempts, before resetting to 0 and
increasing the lock time by a factor of 2 - it's in minutes.

Is this a good method to lock out a brute force?

I'd have logic like this on my server: - abstracted

....
* on request to server do below  *

db.query("SELECT * FROM attempts WHERE IP= *REQUEST.IP* ",function(result){
    if (result.rows.length > 0 && result.rows[0].attempts > 5) {
        if (CheckIfExpired(results.rows[0].lock)) {
            if (loginFail) MultplyLockBy2();
            else RemoveFromAttemptsTable();
        } else res.status("403").send("You're locked out");
    } else normalLoginAttempt().ifFal(add1toAttempts());
....

I have a feeling there's a more efficient way to do this natively in SQL, I'm a novice with SQL.
(I'm using postgresql).

After looking at this I'm guessing I'd need a start-time field aswell, so I can calculate when the lock has expired.

EDIT: after doing research I've read / am thinking about implementing fail2ban which check's Apache/nginx logs and blocks users; a cookie that allows a user to connect back into their account without Captcha / proof of work, and then make others get captcha; or just a captcha in conjunction with a lockout;

There are some problems I see with your approach.

Firstly, it provides a route to a denial of service attack; someone just needs to keep supplying bad passwords from an ip address to lock it out. Assuming a 1:1 correlation between users and ip addresses is a bit silly.

Secondly, in order to reset an account you need to delete data which is useful in terms of an audit trail. Were you planning on reseting the account after a successful login?

Thirdly, it does not protect against a distributed attack - or one with spoofed addresses.

If it were me, I would go with....

SELECT SUM(score)
FROM (
   SELECT COUNT(*) * ipweight AS score
   FROM logins
   WHERE failed=true
   AND ip=INET_ATON(*client_address*)
   AND ip <> *trusted_device*
   AND timestamp>NOW - INTERVAL *config_value* MINUTES
   UNION
   SELECT COUNT(*) * acctweight AS score
   FROM logins
   WHERE failed=true
   AND username=*supplied_username*
   AND ip <> *trusted_device*
   AND timestamp>NOW - INTERVAL *config_value* MINUTES
   UNION
   SELECT COUNT(*) * allweight AS score
   FROM logins
   WHERE failed=true
   AND ip <> *trusted_device*
   AND timestamp>NOW - INTERVAL *config_value* MINUTES
)

(This can be extended with other atrributes such as user agent)

Set a lower threshold than the lockout at which you require the user to complete additional verification (such as a capcha).

Just log the attempt (ip address, username, timestamp, outcome) in the database (not the lockout time).

Note that representing the ip address in its native (integer) format in your database is almost always a good idea. Here it offers the opportunity of aggregating failures across an arbitrary netblock.


What is the difference between ARP and ICMP MITM attack? I want to know the difference between arp and icmp mitm attacks and why someone would use icmp over arp.

I am looking for an educated response comprised of the principles behind both attacks, their typical use and maybe adv/disadv of each.

I am not a specialist, just an aspiring bioinformatician with interests in cyber security, go easy on me.

Firstly, ARP is a protocol used in a LAN to resolve the MAC address of the next or final destination IP. Therefore an ARP MITM attack works by spoofing a MAC address within a LAN in response to a victim's ARP request. If the MAC of the intended machine is successfully spoofed with the attacker's machine, then the victim will send traffic to the spoofed MAC address instead of the destination MAC address. It follows that for this attack to be successful, it must be executed within the victim's LAN. Additionally, for an ARP spoof to be effective you have to be able to respond faster than the actual destination ARP response.

An ICMP MITM attack on the other hand is accomplished by spoofing an ICMP redirect message to any router that is in the path between the victim client and server. An ICMP redirect message is typically used to notify routers of a better route (see http://www.cisco.com/c/en/us/support/docs/ip/routing-information-protocol-rip/13714-43.html), however it can be abused to effectively route the victim's traffic through an attacker controlled router. While this attack does not require LAN access, the disadvantage is that many routers have static routes or do not accept/process ICMP redirect packets.


What's the danger of having some random, out of my control, JavaScript code running on my pages? My website pages reference some JavaScript code from a third-party CDN (analytics, etc). So I don't control what code is there - the third party may change those scripts at any moment and introduce something bad into those scripts - maybe accidentally, maybe deliberately. Once those scripts are changed, the users start receiving and running new code in their browsers.

What risks are raised by this uncontrolled code? What's the worst thing that can happen? How do I get started with managing the risk?

Risk

In the worst scenario, it could render website completely inaccessible for the users, it could perform particular actions as them (for example, requesting account removal, spending money) or it could steal confidential data.

Prevention

Can't be done. If you run someone else's JavaScript on your website, it becomes no more secure than that third-party. You have to host it yourself.

You can get closer to the target, however.

One thing may be Content Security Policy. The example setting of header Content-Security-Policy to script-src 'self' www.google-analytics.com;, would prevent execution of scripts served from other domains than your own or www.google-analytics.com. That way if someone would find some cross-site scripting vulnerability (XSS) that would allow them to add their own inline JavaScript code to your website - it would not run.
Other really cool thing is so called Subresource Integrity. It's essentially adding hash sum of JS you expect to run to the integrity parameter you give to the script tag.

<script src="https://example.com/example-framework.js"
    integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/uxy9rx7HNQlGYl1kPzQho1wx4JwY8wC"
    crossorigin="anonymous"/>

You can generate those hashes online at https://www.srihash.org/ or with command:

openssl dgst -sha384 -binary FILENAME.js | openssl base64 -A

This of course has downsides, e.g. analytics providers may change their scripts and you will have to change integrity parameter to keep them running. It's also pretty new feature (Chrome 45.0+, Firefox 43+, Opera 32+, no IE, Edge or Safari support at the moment), so you lay your client's security on their own software.

See also 3rd Party Javascript Management Cheat Sheet from OWASP.


Bypass Local File Inclusion(LFI) prevention filters I have these two LFI filters and i want to bypass them
        $bad = str_replace('../','',$_GET['bad']);
        while( substr_count($bad, '../', 0)) {
            $bad = str_replace('../', '', $bad);
        };
        include("./".$bad);

I tried various ways and i was not able to bypass them, also the php wrappers are mostly used in php 5.* versions and before and i have php 7.6 version.

I don't think you can do it, unless there are insecure and exploitable symlinks that allow bypassing the '../' removal filter and are reachable down from the current directory.
In other words, I believe that LFI filtering is adequate.


Can posting "howsecureismypassword" results be a security risk? Say that someone asked how secure my password is, if I give them the https://howsecureismypassword.net/ results of it, (especially if I disable the named numbers mode,) can that person brute force with the website's algorithm and possibly find my password?

By posting those results, you are limiting the pool of guesses the person has to use. However, this does not make brute forcing faster in a practical way, it simply limits the guesses the person will try. With a strong password, this brings diminishing returns -- excluding guesses without numbers or symbols doesn't help all too much.

However there is one exception: if the site reports you're using a "commonly used password" then it makes brute forcing extremely fast. And if you're using a password from that list, you deserve it!


How do I use "openssl s_client" to test for (absence of) SSLv3 support? In order to mitigate the "Poodle" vulnerability, I'd like to disable SSLv3 support in my (in this case, TLS, rather than HTTPS) server. How can I use openssl s_client to verify that I've done this?

OpenSSL s_client
To check if you have disabled the SSLv3 support, then run the following
openssl s_client -connect example.com:443 -ssl3

which should produce something like
3073927320:error:14094410:SSL routines:SSL3_READ_BYTES:sslv3 alert handshake failure:s3_pkt.c:1258:SSL alert number 40
3073927320:error:1409E0E5:SSL routines:SSL3_WRITE_BYTES:ssl handshake failure:s3_pkt.c:596:

meaning SSLv3 is disabled on the server.  Otherwise the connection will established successfully.
Nmap
Alternatively, you can use nmap to scan server for supported version:
# nmap --script ssl-enum-ciphers example.com
Starting Nmap 6.47 ( http://nmap.org ) at 2014-10-15 03:19 PDT
Nmap scan report for example.com (203.0.113.100)
Host is up (0.090s latency).
rDNS record for 203.0.113.100: edge.example.com
Not shown: 997 filtered ports
PORT    STATE SERVICE
80/tcp  open  http
443/tcp open  https
| ssl-enum-ciphers:
|   **SSLv3: No supported ciphers found**
|   TLSv1.0:


Secure Custom Registration Links I'm working on a website that allows a current user to invite another individual to be friends by typing in the non-user's email address. The non-user would then receive a custom registration url by email which would, when used, automatically connect the two users, giving each access to the other's private information.

The custom registration urls will be somewhat protected by use of cryptographically random nonces (i.e., site.com/very-long-random-nonce), hopefully protecting against replay attacks or people simply guessing someone else's registration link.

My concern is that, if the email should be intercepted in transit, the interceptor could gain access to the inviting user's private information. How can I ensure that only the intended recipient will receive and use a custom registration url?

For this your main concern is making sure that the information is only accessible to the intended recipient; which sounds a lot like what public cryptography / PGP tries to achieve.

Unless you want to see if the target non-user has a PGP key published, or if you can get his certificate to encrypt the email with his public key; I think you'd just need to assume that he/she will be the one reading the email.

Another note is that a user can determine whether this person is really who he/she claims to be, maybe by inserting a secret question that only the recipient know. But that would make it a pain to use.


How does Cisco Anyconnect VPN work? I am looking for a deep down technical explanation of how it works.

My understanding is its an SSL VPN and works as follows:

- Anyconnect creates a TLS session to the configured remote servers, authenticate the user and fetch some network details like the IP address

- sets a local tunnel interface with that IP

- configures the routing on the host to point all traffic to the tunnel.

Assuming this is correct, how does the tunnel interface packets get sent over the TLS connection ?

One of the mentioned advantages of SSL VPN over IPSec VPN is that the former doesn't need a client software. If Cisco Anyconnect has to be installed anyway is there still an advantage with SSL VPNs ?

I think the common descriptions of "SSL VPNs" conflate three different things:

VPNs which use TLS or DTLS as their base protocol. (Examples: AnyConnect, SSTP, arguably even OpenVPN.) These still require a client just like any other protocol does – there's nothing magic about the usage of SSL/TLS here, and no great advantage (except perhaps passing through IDS systems unnoticed).
VPNs which, regardless of protocol being used, launch a JavaWS or ClickOnce applet directly from a website. Now that's still technically a client, just one that doesn't have to be explicitly installed. I don't get why people call this kind "SSL VPNs" (is it because the client runs from a HTTPS website?), but they do it anyway.
Finally, "VPNs" which aren't actually IP-layer VPNs but merely web-based gateways (proxies; portals) to internal webapps. These don't require a dedicated client because they don't actually intercept IP packets from the OS – they work like ordinary websites that you visit over HTTPS (therefore SSL).

So what makes things confusing is that the same Cisco AnyConnect product can fit any of these descriptions: its protocol is based on DTLS; it provides a Java-applet client; and it provides a webapp gateway in addition to traditional VPN.

But that doesn't mean the same mode fits all three descriptions at once: e.g. if you want to use the system-wide VPN mode, it still requires a client that runs on the local computer, creates a virtual interface, and so on.


Is this Ubuntu server configuration secure? I'm new to Linux and security matters. I have a vps with Ubuntu 12.04 server and I wonder how secure this server is.

I set up ssh passwordless login and disabled ssh login for root. I update security packages. I don't use a firewall. There are only two services which listen for  external incoming connections:

~ > sudo netstat -tupln
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      1272/nginx
tcp        0      0 127.0.0.1:41333         0.0.0.0:*               LISTEN      1232/domain.lighttpd
tcp        0      0 127.0.0.1:4949          0.0.0.0:*               LISTEN      908/munin-node
tcp        0      0 0.0.0.0:21012           0.0.0.0:*               LISTEN      807/sshd
tcp6       0      0 :::21012                :::*                    LISTEN      807/sshd

Is my system secure? Is it worth to use a firewall to shield these two services?

Firewall does not shield services that need to be accessible from the network.

Is this a VM or a container VPS? If it's a container based VPS (done using OpenVZ or vserver), then you are quite limited in what you can do to improve security. If it's a VM, you can install a kernel patched with Grsecurity and use a MAC solution like TOMOYO, AppArmor or SELinux to isolate your services.

With passwordless login I presume you use keys? Also you need to learn more about the services you are running that are exposed to the network (nginx and ssh). Learn configuration files and what options you have.

Read man pages for config files. Certain configuration options (and combinations of) can lead to a vulnerable system.

Your system will always be insecure until you (admin) know your system, dangers and security mechanisms at your disposal.


Prevent Session Hijacking, where an attacker steals Session ID(cookie) from the browser physically Consider a case, where an attacker has physical access of user's machine for 20-30 seconds.
The attacker can use this time to steal user's cookie (say using EditThisCookie plugin) and send the cookies to himself (say by hangouts, facebook, mail, etc).

The account of the user is compromised forever.
I have tried out the experiment myself, where say XYZ's-cookie "X" is stolen from my system. After which I change the password of my XYZ account. Still the attacker can access my account by using cookie "X".
Also, sometimes it has happened with me that the cookies stolen ("X") when inserted in the browser doesn't work. I want to know why this weird behavior happens and what kind of state is stored in cookies. I have read about the expiry date to be stored in the cookie, but generally it's stored 1 year or so from the current date (am not sure about this fact though).

I also wanted to know if there's any method in current web architecture to prevent the click-jacking attack where cookies are physically stolen (as described above).

The cookies are there to avoid authenticating via a password for each web transaction (otherwise each protected page would need to be reauthenticated every time it is accessed).

In that sense cookies are independent of the password.

They should be checked by

the browser which verifies that their validity has not expired. The server should never rely on this check for security means as the browser is controlled by the client (and can elect not to check the validity)
the server which ensures that the cookie it retrieves from the client is still valid according to its (the server's) own criteria (it should keep track of the validity of the cookies independently of a possible "validity time" within the cookie).

Therefore the fact that you changed the password does not necessarily mean that the cookie is invalid. It should be the case because the server should invalidate them on his side.
Logging out is the normal way (or rather - should be) to invalidate sessions.

There is not much more beyond that (in terms of cookies as an authentication mechanism) - they are one possible way to avoid constant reauthentication.


How to keep important data secure in case of total compromise? The question is simple, and really interesting at the same time.

How would you keep your data secure in case of a total compromise of your infrastructure?
This should NEVER happen, but as we all know, bad things happen, and I'm preparing for the worst.

I have two types of data:

Log data (access logs from the application itself, security logs etc.)
MySQL backups

We already have a system in place where the MySQL backup and all logs including is getting transferred periodically to Amazon S3 storage.

This will protect us in case of a total crash (should never happen either - Doomsday prepping!)

But what if a malicious hacker were to compromise the entire system? What would be the best solution? He can easily take out our API key and misuse it to delete data from Amazon S3. We have expire rules in places so versioning is a no-go.

I'm thinking of some kind of write-only service running on an entirely different system?
Maybe something like Rollbar.com for logs and an entirely different server which pull down the database periodically, for completely off limits storage?

What's your thoughts on my proposed solutions? Do you have any ideas? Comments? Is this secure enough? Any alternatives?

Write additional backups to media (DVD/Blu-ray/Tape or a hard disk) and store them offline. This place has to be save from theft, physical damage, ...
Write your logs to another server using rsyslog. This should be a hardened server and remote login must be disabled.

You should also think about encrypting your backups. So if someone gains access (remote @S3 or physical with your backup data) he can not take advantage of your data. Asymmetric encryption has the benefit of allowing you to keep the private key of your system.


BYOD - Confirming that Devices are Approved We currently run a Cisco ASA 5510 and a RSA token to authenticate users to our network for VPN access. The company is trying to start BYOD but would like to make sure that the PC has been approved by corporate before hitting our network. This is not something that is currently in place as anyone with an RSA token and Username/Password can install the cisco connect software on any PC they own and VPN in.

We currently employ AD in our network, RSA, and the ASA5510 is the device serving the VPN connection.

TL:DR, We would like to be able to effectively identify a users PC before allowing that PC (if its not authorized) to hit our network via VPN.

There are agent-based NACs that will not allow a device to connect to a network unless certain conditions are met, like:

Certain other software installed, like AV
User is part of the approved user set
Security settings are configure a certain way
etc.

These require a lot of management and enrolling new devices can be a bit of a pain, but these types of systems do provide what you are looking for. You say that the IBM system would take too much configuration to work, and I suspect that you'll find the same problem with most of them.

There are agent-less systems that use a combination of MAC, OS patch level, and WMI info to and determine if a device is permitted, but they have varying levels of success. I have used one to great effect, but it, too, took a lot of management.


Could a virus force a phone to download an app and spread it? I'm writing a sci-fi story that includes a malicious app that spreads globally. The developer publishes an app without knowing it's infected, and it spreads because it forces phones to download it. Are there any mechanisms that might make this happen?
Of course, it's sci-fi so it can all be theoretical but I'd love to make this as realistic as possible. I assume it would have to access the OS somehow. Perhaps by exploiting app permissions? Any guidance or expertise is greatly appreciated! Thanks in advance.

Yes. This is plausible. What you're describing is worm-like behavior. App permissions are possible. But at some point it would probably need to exploit a vulnerability in the phone's software. It could be a chain of the app permissions enabling the exploitation of the vulnerability. In the real world, you sometimes need to chain together pieces like that to form a complete attack.
At the risk of splitting hairs, there is a distinction between a virus and a worm:

Virus - Infects a specific object like a file. When that file runs, it also runs the virus. The virus cannot run itself.
Worm - Usually a standalone program. Self-propagates across networks.

Credit to John Brunner for coining "worm" in The Shockwave Rider.
The most notable early example of an actual worm was The Morris Worm of the 80s. It's an interesting story. A logic flaw in the worm unintentionally led to a DDoS attack.


Hide algorithm and variables I have some variables in my algorithm that I would not want others to see.

Party A would write an algorithm which will use my variables. But party's A algorithm should remain hidden i.e. I should not see it.

I run A's algorithm  which uses my variables and it produces an output.

In reality the problem is that Party A might be an adversary.
There are lots of parties writing algorithms so there is not only one party A. We can assume that most of the parties are not bad.

Is there a way to prevent my variables from leaking out to Party A?

If someone knows a paper about this could you point me in the right direction. The solution can also be one that is indistinguishably hard.

You are looking for something called fully homomorphic encryption.

The gist of it is that party A can compute stuff using your variables without knowing your variables (mind blown, I know).

It would be using special encryption such that you can do operations on the ciphertext such that the decrypted result is the same as if you had done the operations to the plaintext values.

In other words: E(x) + E(y) = E(x + y)

As for implementations, I recommend looking into tfhe, etc.

As for papers, this one is the among the most well-known although it's techniques have been improved upon since it was published: https://crypto.stanford.edu/craig/


Is it possible to have a high confidence that a password is not being reused? Have a few thoughts on the topic, but the general gist is if a user inputs a new password, is it possible to have a high confidence that a password is not being reused elsewhere?  By elsewhere, I mean on any systems not controlled by you.

If the user is allowed to pick their own password, then no, it is not possible.  Nothing prevents that user from re-using some other password from other systems you do not control as long as it fits all your password requirements.

If you do not allow a user to pick their own password, but generate a high-entropy password for them then it is possible -- if you pick a random new 80-bit password for them like LDhrcqKYcm its highly unlikely that before generation that password is used on any other systems.  Granted once you give it to the user, there's nothing preventing them from memorizing it and deciding to use it on some other system that doesn't put limits on their password.


Is PGP secure against a rogue keyserver? Imagine Eve taking over the keyserver both Alice and Bob are using.

By replacing Alice and Bob's public keys with her own, she can do a man-in-the-middle attack decrypting messages and relaying them re-encrypted with the original keys.

Even if Alice and Bob sign their messages (by encrypting a hash with their private keys), Eve could just replace the signature with her own, as Alice and Bob only have falsified public keys to verify the signature.

Even if Alice's and Bob's public keys are signed by other users, Eve can also sign her fake key with a lot of other fake users. To verify the key signatures, Alice and Bob again have to rely on the keyserver to supply the public keys to verify these signatures.

The only way to verify that the signed public keys are genuine is to follow the chain of trust back to Alice and Bob themselves, as Eve can't forge their signature. But for one, the chain of trust might not even reach Alice and Bob and, more severe, even to verify their OWN signature, they need to have access to their own untampered public keys, which would make having them around locally just as important as the private key.

This fact is not mentioned in usual PGP manuals, the public key is not protected by a passphrase and it might even be overwritten by an 'update' from the rogue keyserver.

Where am I wrong in my assumptions? What measures are in place to prevent this?
Does the 'verify signature' function of GnuPG indeed follow the chain of trust back to the own private key, or does it just check the first level of signatures with public keys from the keyserver?

Update:
I've already found "Shouldn't GPG key fetching use a secure connection?" and "Is connection to keyserver encrypted?". Both state, in short, that the complete PGP system is useless UNLESS you can find one (or better more) path(s) from your own (or another ultimately trusted) key to the sender. But still they don't mention that this ultimately boils down to the integrity of your locally copy of your own (or other ultimately trusted) public key. So the question remains: is this enforced and checked by GnuPG?

A PGP key server is just a big wall where anybody can glue some piece of paper, to the view of all people who happen to walk along the wall. Nobody actually trusts the wall for providing any kind of assertion about the truthfulness of what is written on the papers; that's just a wall, an archetype of mindlessness.

A PGP public key might be trusted, or not, depending on the signatures by other key bearers that you will find on that key. This is the Web of Trust, the kind of PKI that PGP uses. Signatures are completely independent of how the signed data was stored and transferred, and that's the whole point: nothing in this system relies on the key servers to enforce any security property at any point; and, similarly, signed keys can be sent over emails, phone lines or even avian carriers: it does not matter.

The worst a rogue key server can do is to cease to do its job, e.g. by deleting some of the keys is contains. It won't have much impact, except that it would make it more difficult for people who do not know each other, and yet want to send emails to each other, to build chains of signed keys and gain some trust in their respective public keys.


How to replace a constant identifier, for a resource on a network, with a variable one? I guess the example can make it easier.

Assume each Client on a network has an identifier(some alphanumeric sequence) which identifies it uniquely on the network. Each time the Client corresponds with the Server over the network(encrypted), the Client sends its identifier to identify itself. Now if somehow this identifier is read off the memory of the device in some way, that device can be impersonated.

Is there any way this weakness in a system can be done away with? We sure can force the Client to change its identifier at end of every session and inform the Server of the new identifier, but this would again remain stored in memory.

I hope I have managed to explain in clear enough. Thanks for your time and attention already.

/////////// Edit ///////////
I am strictly looking for a solution which works in the case of a completely subverted Client program/OS/environment, which means the attacker can wilfully hook into any of the system events and processes.

/////////// Edit ///////////
I'm thinking of using a combination of these ideas. So in case someone comes looking here, this might help.
http://en.wikipedia.org/wiki/One-way_function & http://en.wikipedia.org/wiki/Oblivious_transfer

All modern authentication systems assume at the basic level that the client holds some type of information that can be used to prove it’s identity and that information should be kept secret. That could be a user name, password, public/private key pair, etc...

If that information is compromised then the authentication chain is broken and the secret needs to be changed.

In your questions and comments you mention that the client is completely subverted which basically rules out an authentication system and that user interaction is not possible. Obviously this is no small matter and could be made much harder with other layers of protection to prevent the host from being compromised in the first place.

However assuming the client is completely compromised the question is not how you implement an authentication system but how you perform integrity verification of the client. This could be achieved through behavioural analysis more specifically in the realm of Intrusion Prevention/Detection. If you can’t trust the client then use of an endpoint agent on the client would not be an option and your detection method would need to be completely external from the client.

This leaves you with possibly two options that I can think of:

Network based Intrusion Prevention to quarantine suspicious clients from the network.
Hypervisor based protection such as VMware’s vmSafe API (vmSafe) which allows out-of-box inspection of a client. Which means that you can hook into an API that allows you to inspect what is running on the CPU and in memory without being inside the attack surface and vulnerable to an attack. In this case protection for root kit and virus detection is already available.

In both cases your exact requirements may not be met, it is unclear your exact intent however it is possible. However these solution would still be used with an authentication system on the client, just used to help detect if the client is compromised.

Hope that helps, if not perhaps you can give some specifics on the exact implementation.


Is it possible to ensure detection and logging of all attempts to copy data out of a system? I am cross-posting this question from Serverfault, because I am in doubt where it fits best.
Say I have a server set up for processing sensitive data. The few authorised users of the system are instructed not to copy any of the sensitive data out of the platform, but could in principle do so using scp etc. This is similar to my car being able to drive about 200km/h although I am not allowed to do so anywhere around where I live.
Can I somehow detect and log (preferably via auditd, but could be other tools) if a user somehow copies data out of the system?
I suppose I could explicitly monitor the use of commands such as scp, rsync, ftp, sftp etc., but then again there may be other tools I am not monitoring, users' own programs, malicious users' renamed copies of common copying tools etc.
I imagine some things might be more reliably detected at the network level, but still: would a sufficiently determined malicious user not be able to for example sneak data out through an encrypted network connection where I cannot monitor what is being transferred?
Edit:
Examples
I have files '/data/sensitive1.csv' and '/data/sensitive2.csv' residing on the system. Users can read these, but have been instructed not to copy this data out of the platform. Can I reliably detect if anyone does it anyway? Can I detect and log if a user does:

scp /data/sensitive1.csv some_remote_system:/somewhere/
It should be easy enough to audit-log scp, but what if the user uses another tool that I have not thought of?
cp /data/sensitive1.csv /home/user/some_other_name.txt
scp /home/user/some_other_name.txt some_remote_system:/somewhere/
This would still show up by audit-logging the users' user folders, but I guess it complicates the audit trail?
python users_own_script.py /data/sensitive1.csv
This could be a perfectly legitimate processing of the data, but as far as I know, typical audit-logging would not easily show if the user's code has perhaps copied data out of the platform. I know how auditd could be set up to log that /data/sensitive1.csv was accessed and maybe some network monitoring would show that some data was transferred out of the system via some encrypted network connection afterwards, but is it not difficult, if not impossible to tell if this data was in fact the contents of /data/sensitive1.csv?

It's possible to monitor access to select data. It's possible to monitor selected tool use like scp.
I've lost track of how many times I've seen claims of security because all data is kept in the cloud or something similar. What is often forgotten is the underlying detail of function. If a user is reading/viewing the data, it's on his device! It can be made inconvenient to extract it but photographing the screen always works.
If the data is never viewed, just processed, then you can attempt to detect exfiltration of the raw data. Common mechanisms include:

Forcing all access through a decrypting MiTM type monitor gateway
Traffic monitor triggers on size & time (assuming large data)
Unusual database queries

All of these mechanisms can be defeated with sufficient access. Fundamentally you are asking about Insider Threat. There are whole industries marketing tools that claim to detect anomalous activities and insider threat patterns. Depending upon details and environment, some of these tools can work fairly well, none are perfect.


S/Key as an alternative to UNIX passwords There is this password system called S/Key I saw on the Internet. Can someone give me a brief description about S/Key and how it works? Can S/Key be an alternative solution to the UNIX password system? Or is there another better alternative? Something that would not be vulnerable to brute force password guessing attacks?

Thanks very much!

For a brief description, see Wikipedia. This is basically a one-time password system: the user does not have a single password, but a long chain of passwords, each password being usable only once. The point is that if a key logger grabs a used password, then the attacker gains nothing because once a password has been used, it no longer grants any further access.

The system is quite nifty: there is an initial secret (W) which is not stored anywhere. From W is produced a chain of passwords, with a hash function h: h(W), then h(h(W)), then h(h(h(W))), and so on. The passwords are used in reverse order, and, at any time, the server stores the last used password, and grants access if the user presents a password which, when hashed, yields the currently stored password.

On the user side, this requires that the list of password is printed on paper, or that the user owns some sort of device which contains the list of password or can regenerate it on demand (the device would store W).

All these passwords are not really "passwords" in that the human user does not choose their contents, and does not remember them. They are "keys" which the user happen to type with his fingers on a keyboard. Human users rarely like the use of one-time passwords.

A generic problem with one-time passwords is that they tend not to work with systems which do password-based encryption of other data elements (typical of Windows systems).


Doing a demo about open wireless networks exploiting with Firesheep A collegue and I have been asked to do a demo where we show off stealing Facebook sessions with Firesheep. I've never used Firesheep before myself, but I reckon it should be a simple task.

I know the demo will raise a lot of eyebrows and many will be actually scared knowing they are using an open wireless network every day with their cellphones (won't go into any more details on this, but its a fact).

Does anyone have any recommendations on what types of questions I should be prepared to answer? Anything in particular I should show in the demo, except just showing I'm logged in as the demo user?

What about MSN traffic... Is it possible to demo sniffing a MSN conversation as well?

What about securing against this? The users will still be using the open wireless. Is the only way of securing yourself by using a VPN to a secure connection?

EDIT: I know firesheep does not capture MSN conversations. Anyone got any recommendations on a tool which could demonstrate this?

Firesheep just shows off cookie-based session attacks.  MSN does not use cookies.  However, MSN does send conversations in clear-text (just not the auth), but firesheep can't pick it up.

VPN is one way to secure the connection.  Another is to only create sessions on websites that only run the full session through SSL.


Best way to manage private keys for users of an application? We're building an application which will leverage blockchain for financial transaction within itself.

We won't be forcing users to manage their own keys. Our clients (we're building a B2B platform) will manage keys for their users. We are building a white-label platform and need to provide key-management as a solution.

We don't want to develop the key management system ourselves.

The needs of the system:

Securely store private keys of users
Sign data with private keys within the system (no decrypted keys leaving or entering)
Generate new keys
Communicate with our backend through an API

We've looked into self-hosted HSM and CloudHSM solutions. Alternatively we would use HashiCorp Vault or Amazon Secrets Management.

What are the best practices?

When it comes to private keys or secrets that are critical such as in the case of cryptocurrency where if you loose the private key the funds are gone forever, always rely on hardware, less on software and never on cloud. You can use cloud resources for other things, but never give your critical assets if their loss means you're out of business or you'd suffer a huge impact. HSM are probably the best solution at the moment. I wouldn't suggest using Amazon's solutions, I think they're known for not having the greatest security. And you can choose whether to host the HSM by yourself or hold them in third party vaults depending on the amounts. You don't want to risk your well being by holding too much amount and become a risk yourself, but if you handle your assets to third parties, you want to make sure no one from there could get their hands on your assets as well.


Casting return from ClassUtil.newInstance I started getting into java security and had a question I could not find an answer to.

Lets say we have a web application that uses the following code, and that the UserControlledString can be set to be whatever class we want:

SomeClass someClassObj = (SomeClass) ClassUtil.newInstance(UserControlledString);

Would it be possible to exploit this and cause harm? From what I can tell most likely not but I thought I'd ask.

It depends on what some class is and what you are doing with it. In an of itself, there is nothing inherently insecure about it.


Are there any systems out there that use a one-time pad? I'm still new to information security, but I have read a bit about the one-time pad. The point that sticks out to me the most is that it is supposedly unbreakable. Has this method of encryption ever been incorporated in any internet web applications on a larger scale? How would they pass they key?

The problem with a one time pad, is that is must be equal in length (or longer) than the data being encrypted , and must never, ever, be reused.

Just as you indicate, how would they send the key?, the OTP must then be sent in a secure way... however that is the problem that is usually left to the user and is generally why OTP is useless.

If you have the ability to send a large OTP securely, then you might think you could simply send the stuff you want to encrypt directly to the recipient over that secure channel.

However the benefit of a OTP is to move secrecy through time. If you have a secure channel now (e.g. an in-person meeting) you can exchange an OTP. You have banked some secrecy for later. Later when you do not have a secure channel, you can use up a part of your pad to make your message secret.

The improvement over OTP is where they make a small seed (a key) and use an expander called a PRNG to expand that key into what is essentially a stream cipher.  This way you're only sending a small amount of data securely, and can encrypt lots of data with that expanded key. This is called "key stretching".


Privacy concern: Services requiring a phone number for signing up Whenever a service requires an e-mail address for creating an account, I feel mildly uncomfortable, but I can easily eliminate my privacy concerns by setting up a new e-mail address that forwards mail to my regular one. However, a growing number of services have started requiring a phone number for signing up recently, and I really don't feel comfortable sharing my phone number with them.

Is there a way to work around this unjustified (at least in my opinion) information greed of services? I know that if I were in the US, I could set up a virtual phone number using Google Voice, but I am not aware of similar well-known services for European users. Of course one can find smaller virtual phone number services by doing a web search, but signing up for an arbitrary unknown virtual phone number service seems just as bad (maybe even worse) than giving my real phone number to a well-known service that requires it.

As always, it depends on your threat model. What kinds of privacy intrusions are you trying to protect from, and by whom? It is true that because most people only have one phone number (and one email address), those are used as unique identifiers to aggregate seemingly disparate dossiers of your online and offline profiles, devices, locations, and behaviors. So having multiple identifiers that you use in some systematic way can be useful to reduce this kind of routine commercial (and political, etc.) tracking.

I'm not familiar with specific tools for European users, but having a spare phone number (or multiple) can be achieved by getting one or more virtual phone numbers (assuming you don't have to disclose much personal information to get them), or by getting as cheap a SIM as you can (if it's billed by usage and you only use it for some set of online accounts, you presumably would only be getting a few SMS or data notifications on it). But definitely do avoid sketchy companies, probably not worth the risk.

You may be able to set up VoIP numbers using a service like the 3rd option here, they appear to support EU customers:
https://source.opennews.org/articles/shields-using-signal-without-your-phone-number/


How SSL Handshake recognise any attack I already know that a replay attack on an SSL handshake is ineffective, but if we suppose that an "intruder" has listened and has got all of the information from a previous handshake, how will the server recognise the attack?

This is for SSL with RSA one-way and for SSL with RSA one-way: verification on phase 2.

Could you please give advice?

The SSL handshake includes random data from both client and server. While the attacker might replay the ClientHello which includes only the random data from the client he cannot complete the full handshake by just replaying previously captured data since the messages needed for completion also depend on the server side random data, which will change with each new handshake.


Web Service Security We are currently designing a Web Service that returns a JSON formatted messages. The following are the planned implementation for the service's security:

An SSL Certification to the service for the communication security over the internet.

  Transport Layer Security (TLS) and its predecessor, Secure Sockets Layer (SSL), are cryptographic protocols that provide communication security over the Internet. The server sends back its identification in the form of a digital certificate. The certificate usually contains the server name, the trusted certificate authority (CA) and the server's public encryption key. - wikipedia.org

Encryption of sensitive data using hashes and salt.

  Encryption is in Symmetric (Rijndael) Key - Rijndael can be specified with block and key sizes in any multiple of 32 bits, with a minimum of 128 bits. The blocksize has a maximum of 256 bits, but the keysize has no theoretical maximum. - wikipedia.org

Client Authentication using custom username and password validator

  WCF allows for custom user name and password authentication schemes, also known as validators. - msdn.microsoft.com

The service will be consumed by different clients and the data should be secured. The following are the possible risks[1]:

Broken Authentication and Session Management - Application functions related to authentication and session management are often not implemented correctly, allowing attackers to compromise passwords, keys, session tokens, or exploit other implementation flaws to assume other users’ identities.
Insecure Direct Object References - A direct object reference occurs when a developer exposes a reference to an internal implementation object, such as a file, directory, or database key. Without an access control check or other protection, attackers can manipulate these references to access unauthorized data.
Security Misconfiguration - Good security requires having a secure configuration defined and deployed for the application, frameworks, application server, web server, database server, and platform. All these settings should be defined, implemented, and maintained as many are not shipped with secure defaults. This includes keeping all software up to date, including all code libraries used by the application.
Insecure Cryptographic Storage - Many web applications do not properly protect sensitive data, such as credit cards, SSNs, and authentication credentials, with appropriate encryption or hashing. Attackers may steal or modify such weakly protected data to conduct identity theft, credit card fraud, or other crimes.
Insufficient Transport Layer Protection - Applications frequently fail to authenticate, encrypt, and protect the confidentiality and integrity of sensitive network traffic. When they do, they sometimes support weak algorithms, use expired or invalid certificates, or do not use them correctly.

If an attack had succeeded in penetrating in our service, a great loss will fall in our company. The following are the possible result of a successful attack:

Any data manipulated in any malicious way might cause a great loss into our company's profits.
Accessing of unauthenticated clients allows them to change and add malicious data and/or slow down or break the service causing the service to be inaccessible.

Is our planned implementation for the service's security sufficient enough to prevent these risks? What other security issues we need to consider?

[1] Risk name and definition are based on OWASP Application Security Risks.

I suggest that you elaborate more on what is the threat model that could cause a great loss.  In general, I would question whether the web is the right technology to deploy this: failures of web security are commonplace, so if any security failure could truly cause a great loss of profits, maybe you should rethink the entire initiative.  But perhaps you can explain more about the highest-priority risks in your setting.  I imagine there is a server, and there is a client.  There are multiple threats.  We could worry about a malicious client that manages to change the authoritative copy of the data on the server.  Or we could worry about an attacker (perhaps a malicious client) that is able to tamper with the data that other clients see.  Or we could worry about a malicious client who is able to access confidential data, without authorization.  Or we could worry about break-ins to the server.  What are the highest-severity risks in your setting?

I'd also say that I'm having a hard time telling what your precise plan is.  I'm not familiar with what a "SSL certification" is.  Do you mean that you use SSL for all connections to the JSON data?  You also don't say how the encryption is done (details matter), or why you need encryption in the first place.  You also don't say if there is any access control, and if so, how that is done (how is authorization and authentication done?).  So there is not enough to review your system as the question currently stands.

Let me start with some general advice: given the potential for great loss to profits if there is a security failure, you need to hire an experienced security professional (perhaps as a consultant).  Give them full access to your system, and ask them to review the security of your system.  Ask for architectural risk analysis (threat modelling), source code analysis (e.g., for security vulnerabilities), and advice about how best to protect yourself.  If great profits are at stake, you shouldn't rely upon this web site.

Without any details, it is hard to provide specific advice.  But I'll make some suggestions:

Deploy a dedicated server to provide access to this data, and use it only for that purpose.  Lock it down tightly (there are many guides on this site on how to harden a server).
Use SSL sitewide: i.e., use only HTTPS, not HTTP.  Don't use HTTP for anything; use only HTTPS.  Enable HSTS.  Set the secure flag on all cookies.
Think carefully about how you will authenticate users.
Adopt good security practices, such as integrating security into the software development lifecycle.  Microsoft has some excellent resources.  Search on this site and you'll find more (Microsoft SDL, BSIMM, etc.).

Note that these will likely not be sufficient: it would be necessary to understand in more detail the goals and requirements for your web service to provide a more complete list.  This is just a starting point.


Become a Cloud Security analyst What learning path would you recommend for someone interesting in focussing on the Cloud Security side and considering remote work in the future?
Many thanks

To become a cloud security analyst, you should have a good understanding of cloud computing architectures and approaches and a firm understanding of the threat models, vulnerabilities, standards, solutions and services offered by various vendors. I have compiled a list of essential concepts related to cloud security in my slideshare presentation. Hope this would be a useful reference material.


Clients trust my custom CA I'm sorry if this is a dumb question.  I'm new to all this.

I have a large number of users.  I need to be able to generate SSL certs for various internal domain names. All of these certs need to be accepted by the browsers.  It is my understanding that I need to generate  a Certificate Authority like this article shows: https://web.archive.org/web/20121016162010/http://www.tc.umn.edu/~brams006/selfsign.html

Then with that certificate authority I can sign a signing request for each domain we need to support.  That will give me a X509 cert that I can use with our web servers.

So, my questions are:

WHAT generated files do I need to put(install, import, accept, etc) WHERE in order to get my browsers to trust all the certs generated by my CA?  I'm sure the WHERE depends on the Browser and OS, right?
I need to make it as easy as possible for my users to accept my CA.  Unfortunately I don't have the ability to automatically push anything.  The best thing I can do is provide a link.  So, I was wondering if it would be possible to create an html page that is loaded over http (not secure) that has an iframe that is loaded from one of the secure servers.  In theory, the iframe page will give some kind of message and allow installation.  My outer page could give instructions on what the user needs to do.  Would that work or am I missing something?  If they do accept the cert will it work for all certs generated by my CA or just this one?

Personally, I would start with a low-cost or free SSL certificate signed by a known and trusted CA for one domain.

Then at that https site that their browsers trust (and that they can recognize as one particular subdomain of your organization), give them an https link to download your CAs certificate with instructions on how to load your CA's certificates in all of the various browsers/OSes that they likely will use.

E.g., firefox: http://www.cyberciti.biz/faq/firefox-adding-trusted-ca/ or in google-chrome: navigate to chrome://chrome/settings/certificates


Unencrypt Data Encrypted by Cryptolocker Virus A while back my computer was encrypted by the cryptolocker virus.  I ended up taking an image of the encrypted drive and then formatting it and installing a new operating system.  Since I have the encrypted drive and unencrypted copies of some of the files that were encrypted, is it possible for me to decrypt the drive by deducing the encryption keys?

I have searched online, and found that for a period of time there was a site to which you can upload a file and it could attempt to decrypt it and give you the key, but it has since been taken down.  Is there any way to get a list of the recovered keys so that I could do this process myself?

Edit:  It has been pointed out to me that this is basically a duplicate of another question about Cryptowall ransomware.  I apologize for this duplication and would like to thank everyone who answered anyway.

Most ransomware use strong encryption algorithms, which means that you will have a hard time trying to decrypt the encrypted files without the corresponding decryption key.

The malware uses an AES key to encrypt files. The AES key for decryption is written in the files encrypted by the malware. However, this key is encrypted with an RSA public key embedded in the malware, which means that a private key is needed to decrypt it.

Read more at: https://www.secureworks.com/research/cryptolocker-ransomware


Should I host portfolio website in public GitHub repository? I have a small portfolio site that I work on in my spare time as a way of demonstrating and applying what I have learned from school/work. Part of this demonstration involves me currently listing the repository as "public" on GitHub for anyone to see and browse. The reasoning behind this is that this means people can see how I approach project management and how I structure my code.

However, this introduces some security risks and other problems. Obviously, I now cannot include any private information, such as passwords of any kind (or private ports, mail variables, etc); rather, this needs to be moved elsewhere. For a while this was fine, until I decided that I wanted to include a blog, which necessitated users, which necessitates login functionality (whole new can of worms).

Because of this, I am now wondering where I can store all of the additional confidential information that I have created. Would I be better off to mark the repository as "private" and simply host some examples on my website? To me this is slightly less ideal, as it appears less authentic (ie. I might have spent additional time refactoring those files, above and beyond what I would typically do in my work).

However, is this something that would be a better idea in the long run, as well as simplifying development by consolidating my files?

UPDATE: The site uses almost no frameworks (other than Foundation 6 for front end markup) as this is the primary purpose of the site (to teach myself the concepts from the ground up).

Primary Question: Is there any benefit to hosting the site on a public repository that can't be gained by only exposing specific files elsewhere? i.e. in a Projects section of the site?

We typically move sensitive information to configuration files with a name pattern, like every one of them ending in .conf extension, so you can simply create a .gitignore entry to match all of them across your project. Files matched according to .gitignore simply doesn't get pushed to the public repository, but you can continue working with them locally. If you want to be nice and allow others to test your application, provide example config files or documentation that contains the right format of data.


Current session cookie shown in a HTML page on request A website exposes this function: https://test.com/getSessionCookie
When an authenticated user clicks on it he gets an html page with his cookie. Could be this exploited in some ways?

An interesting kind of attack that might work in this case would involve iframes (if allowed), social engineering, and a confused deputy issue (where the confused deputy is the user).
You might create a malicious website that contains a fake CAPTCHA request, where the CAPTCHA code comes from the user's cookie and is displayed with an iframe. So, for example, you could place the page that displays the cookie inside an iframe and position it carefully so that it looks good enough. Then show the user a page that says: "Our system needs to make sure you are a human, please copy the following code and paste it in the field below".
That was the first example that crossed my mind, but maybe you could come up with better tricks to convince the user to copy the code and send it to you. You might try to convince the user that the code is a temporary password to access a private area, or an error code they have to communicate to you, or a URL they need to visit. I'm not sure if the user would be able to copy-paste a text string (the fake URL) when part of the string comes from an iframe (the cookie), but you could try.


Is it necessary to enable SSL for client and server that run in same machine? I have a REST HTTP server listen on localhost port and a HTTP client runs locally and talks with the server. The client could send sensitive info (credential etc) to server and the credential is encrypted/decrypted by Windows API.

In this case, do I need to wrap the HTTP server with SSL (to be HTTPS server)?

No. Its not neccessary at all. First, because packet capturing/modifying requires administrator rights. But second, with administrator rights, you are aswell able to modify other processes that you don't own, thus can modify/read the RAM for the client or server before the data is encrypted by the SSL layer, or after its decrypted by the SSL layer.

Thus SSL will neither contribute or compromise anything security-wise, it will have zero effect. It may have effect on performance.

Also, since the private key for the certificate needs to be stored on the very same machine, the attacker could steal that key and use it to read/modify the local traffic.

So SSL will just only make debugging harder and add nothing.


Should I block outbound TCP RST (on closed ports)? I have a range of inbound TCP ports open on the firewall, but usually closed on the host machine.  I see a handful of unknown connection attempts each day, for which the server returns TCP RST.  I wonder, should I configure IPTABLES to silently drop these, so a scanner cannot so quickly learn the status of a port?  If the volume was high, I would do so to avoid paying for the outbound bandwidth, but is there any reason other than that?

Whether you want to take the trouble to do this largely depends on your own threat model and the effort required to make the change.

The effect of filtering access to closed ports is that it makes it harder for someone foot-printing a network to establish potential attack targets.

Theoretically any information provided to an attacker is useful to them, so reducing the amount of information you provides improves your security.

There is also the potential risk that at some point your host might have an exploitable bug in its TCP/IP stack that could be exploited by a scanning host.

Whether any of that matters enough to you, as I say depends on your particular risk model.  In general, I'd say that if it's easy to do, and has no other negative consequences, sure filter the traffic.


Principal DOM Based XSS detect using python I am working for a project make a XSS scan tool using python.
I have a sample url: http://www.foo.bar/index.php?ids=111

I've found that it has a vulnerability by http://www.foo.bar/index.php?ids="><SCrIpT>alert('XSS')</ScRiPt>

A basic different from normal url and xss url is a alert box has been showed in the browser. But when using python, how can i we see that or detect which url is vulnerability?

There is many XSS tools such as: wapiti, w3af,... But how's it work? What is principal xss scanning?

I've tried python request library:

import requests

xss_url = 'http://www.foo.bar/index.php?ids="><SCrIpT>alert('XSS')</ScRiPt>'
r = requests.get(xss_url);
print r.text

normal_url = 'http://www.foo.bar/index.php?ids=111'
t = requests.get(normal_url);
print t.text

But result of r.text and t.text is the same.

I can't look into your problem, as you gave a fake URL for testing XSS.  Here's a real URL demonstrating an XSS vulnerabilities:

http://www.insecurelabs.org/Task/

Using the first task this is a URL that has an XSS vulnerability:

http://www.insecurelabs.org/Task/Rule1?query=%3Cscript%3Ealert%28%27XSS%27%29%3C%2Fscript%3E

Using requests python library, we can request this page:

>>> import requests
>>> xss_url = http://www.insecurelabs.org/Task/Rule1?query=%3Cscript%3Ealert%28%27XSS%27%29%3C%2Fscript%3E
>>> r_xss = requests.get(xss_url)
>>> print r_xss.text

<!DOCTYPE html>

    <meta charset="utf-8" />
    <title></title>
    <link href="/Content/Task.css" rel="stylesheet" type="text/css" />

            Back to task list

Task 1 - between tags

    <form method="get" action="">
        Search: <input type="text" name="query" value="&lt;script&gt;alert(&#39;XSS&#39;)&lt;/script&gt;"/><input type="submit" value="Search" />
    </form>

        Searched for

        Found nothing.

    ...

As you can see right above where I truncated the rest of the HTML content, there is the text Searched for , which is the XSS vulnerability as it is a fully formed


Security implications of syncing with off-site keepass database Is it a safe practice to sync with a Keepass database that is stored on an off-site server?

Database is accessed primarily through my Android running 4.4.2. I access/sync my Keepass database by accessing my Dropbox through the Dropbox app via the KeepassDroid app. I haven't been doing this over a VPN, as Bitmask has stopped working for me ever since the latest update.

Are you worried that someone may break your AES/Rijndael 256-encrypted database? If your key sucks, then yeah, you should be worried.

It's always good to elaborate what your fears are.

If you're afraid that a government agency may have the resources to compromise your KeePass database - I wouldn't be worried about that, they have other ways to get what they need.

If you think a hacking group is looking to break your precious database of cloudy accounts, then it's more likely that you become a victim of a drive-by (e.g. malware on your droid).

In all cases, the baddies will go after the lowest hanging fruit, and in this case it's not the KeePass database - it's as solid as you need it to be. However, your Android may not be as solid as you think. The endpoint is usually the weakest link, especially if it's a phone.


Any way to revoke old key pair? There is a many-year-old 1024 DSA key in the public keyservers under my name. There is a 2048 ELG-E subkey for it. I didn't create these keys, they were created for me by a former employer without my consent. I don't have the private key and it apparently has no expiry date. (Just brilliant.) I know there is no way to remove them from the servers, but is there perhaps a way to crack them and issue revocation certificates? Is the cipher sufficiently aged/small to reasonably be able to crack them these days?

If you didn't create the keypair and never had the private key, then it's not your key; it's a fake that was created by a third party. Anyone can create an OpenPGP key under anyone's name without their consent and upload it to the public keyservers. The fact that this was done by your former employer is irrelevant (unless it means you can contact them and ask them nicely to revoke the key).

The real solution to this problem is the web of trust: your genuine key should be verified directly by your contacts and/or signed by others that they trust (and whose keys they have verified). If your contacts don't understand this, your private communications with them are already doomed, as they will be easily fooled when a malicious man-in-the-middle provides them with a fake key.


KRACK interim guidance stopgap As operator of an important AP, e.g. Stack Overflow developers' office building, can I:

Disconnect everybody.
Change the AP shared key through Ethernet media.
Securely distribute new key to wifi clients.
*Monitor 802.11 AP for ANY ANY deauth messages.  If I get any start at step 1.

Would that work?

Changing the PSK has absolutely no effect on KRACK. KRACK doesn't give an attacker access to the PSK. KRACK is an attack on the process that exchanges the PTK/GTK between the client and the AP. A successful attack will allow the attacker to calculate the PTK much more easily (or in the case of very broken clients set the PTK to all 0's). This will happen no matter what the PSK happens to be and changing the PSK doesn't change this attack in any form.

If you believe a connection between client and AP is compromised, simply disconnecting the client and reconnecting is sufficient to generate a new PTK. Just make sure that connection isn't subsequently attacked and compromised as well.

If you want to protect your "high value targets," you should:

Patch both the AP and the clients.
Don't rely on a single layer of encryption, especially one that only protects from the client radio interface to the AP radio interface.
Enable 802.11w to prevent deauth/disassoc attacks in the first place.


Facebook mobile app is often asking about my phone number for registeration, field is entered already. Where does facebook take this phone numbers? Facebook mobile app is often asking about my phone number for registration. It shows a screen saying that "Keep your account secure and keep using it securely" and "We are trying to help you to secure your account .... register your phone number etc."

And the suspicious side of this is that, the phone number input is filled already as you see in the screenshot. Each time a different phone number appears in this field.

Last time when I saw this screen, it was showing my very old home-phone number, even before Facebook. I have never registered my home-phone number for any website or application, I'm sure about it.

I asked Facebook about this, but no reply received yet. Has anybody ever encountered something like this before? Where does Facebook take this phone numbers? Any idea?

If any of your friends have shared their contact details with Facebook, they may well have picked it up from there. It's buried in the terms and conditions that they have on account creation, so it's very easy to miss...


Copy of files to storage device I downloaded files from an old company computer to an external USB device, can the company tell which files were copied or only that I copied files?

This depends on how they might go about checking it, if for example they where to use a full Forensics examination then there would be registry information stored for, when the device was connected. And from there using a software such as FTK or EnCase it would be possible to see the signature of that devise and potentially follow the files signatures and path.


IP address- is it dangerous for someone to know? The last couple days I was talking to someone online, and this person said that my IP address was this and that, out of nowhere... Which was wrong, probably because I was connected to a VPN (not the point) but still, I'm worried now, how can you even check someone's IP address? Is it dangerous? Why would someone do it? To get my location or any other reason?

Actually it is not dangerous on some aspects, your IP address is your basic identity  to your system when connected to internet and if someone knows it then you can be exploited on some basis for some instant of time.
But it is difficult to establish a persistant connection because every time your pc restarts, it gets its new ip address.
So no need to be afraid.


Certification in secure software development? I'm looking for available certifications for software developers and for companies that produce software products.

Are any available?

If you are looking for training/certification of individuals for secure coding, SANS.org is a good resource. Their training is very good and the certifications are well respected.
https://www.sans.org/curricula/secure-software-development

If you are looking for a security benchmark certification for software products produced by a company, the CIS Security Software Vendor Membership is a good program:
https://benchmarks.cisecurity.org/membership/certified/overview/


Is native OpenZFS (on FreeBSD) block-level encryption secure? I am considering using OpenZFS on FreeBSD. I am not quite sure how secure native OpenZFS encryption is? If somebody steals my server and the disks, is he able to decrypt the files?
In a Discord room I found a possible answer:

Native ZFS encryption is still fairly new in the world of software
encryption, and it doesn't hide as much through obfuscation as more
well-established alternatives like LUKS and VeraCrypt (formerly
TrueCrypt.) However, it lets you protect your data without losing the
efficiencies and features of ZFS, even when the dataset is locked:
creating snapshots, compression, incremental replications, etc.

Is that about right? Are there any important additions to the security of OpenZFS encryption?

According to those slides explaining OpenZFS encryption, it appears that OpenZFS encryption is far stronger than LUKS or VeraCrypt encryption.
LUKS and VeraCrypt use the XTS mode of encryption, which is not authenticated, and is vulnerable to some limited recovery of information when an attacker can have access to the encrypted data at different times. On the other hand OpenZFS encryption is authenticated and at the state of the art. Also, you should take care to disable compression when encrypting with OpenZFS.
However, this authentication comes at a cost and is the reason it was not used in XTS: for every encrypted block in ZFS, 288 bits are used for authentication and encryption metadata (salt, MAC and IV). This is space that cannot be used to record data, so one can record fewer data on the same volume with OpenZFS than with XTS.


Snort rule does not work when combining "content" fields I'm trying to write a snort rule which outputs an alert whenever a web server returns an HTML document containing a specific string.

I've come up with the following rule:

alert tcp any any -> any any (msg:"Yay"; flow:to_client,established; content:"Content-Type: text/html"; http_header; content:"Hello there"; metadata:service http; sid:12345678; rev:1;)

The first content query checks whether the response contains an HTML document, the second one checks for the presence of the specific string I want to test the response against.

The strange thing is, when removing either of the content fields, the alert works fine. In combination, however, it does not.

Does anyone know why?

I know that this is an old question, but this has been something I've run into numerous times, so I figure that providing an answer may help others who have run into this.

My Explanation

In my experience, some versions of Snort have issues when switching from using HTTP options that reply on preprocessor parsing and then switching to not using them.  Given the rule you provided, the first content string:

content:"Content-Type: text/html"; http_header;

Utilizes the http preprocessor and the Snort engine sort of gets into the mode of parsing parts of the request/response.  Following up with the content string:

content:"Hello there";

... without specifying where to find it, the Snort engine has difficulty finding it.

Of course, this is my "theory" formed upon experience and trial-and-error troubleshooting.

Possible Solutions

Specify content:"Hello there"; before the other content (move to the left).  If applicable, specify fast_pattern:only;.
Leave the content:"Hello there"; where it is, but try adding the pkt_data; option prior to it.  This would tell Snort to forget about parsing HTTP request/response elements and move the doe_ptr to the beginning of the HTTP request (i.e. the packet) and then search for the content.  Or, if that content is expected in the file data of the response, use the file_data; option instead.  Again, pkt_data; or file_data; require you to put those options before the content options that need to be affected.


Can a heap/mmap buffer overflow overwrite the stack The following questions regard linux processes with a stack that grows downwards from the end of the process memory.

If I have a buffer overflow on the heap with unlimited size, are there any protection against me overwriting the entire process memory until reaching the stack and overwriting it?
Same question for buffer  overflows in mmaped memory regions, which in comparison to the heap can reside closer im memory to the stack

Thanks!

In theory, because the heap grows up and the stack grows down, maybe it could be possible if both were to grow far enough. However, in practice, it's very unlikely.
There is generally a large, unmapped range of memory between the heap and the stack, and there may be other regions mapped before the stack for shared libraries and such. The problem is, the moment you try to write to an unmapped address or a read-only page, you will trigger a segfault. This will certainly be the limiting factor if you attempt something like this. The same applies to your second question. Unless the memory region is directly adjacent to the stack with no gaps, you will probably have trouble.


What are some recommended open source tools for web browser history analysis? I'm looking at a series web browser histories from various browsers (IE, Chrome, Firefox, etc) and need to do some analysis.  All of these browsers store data much differently, but I was wondering if there was an open-source tool suite out there that would help me to analyze all of them.  If this is just wishful thinking, are there any open-source tools commonly used or is this type of analysis usually done manually?

Web Historian - not open source, but free (as in beer)

"MANDIANT Web Historian helps users review the list of websites (URLs) that are stored in the history files of the most commonly used browsers, including: Internet Explorer, Firefox and Chrome."

Odessa - just for IE, but open source


Remote working. Is my employer able to monitor my activity Due to situation, my employer made a work-from-home policy.
And remote administration tool is not installed, since I did clean installation of the system.

Is my employer able to see my activity?

Let's say that I use my company email.
What steps shall one take to secure his activity?

P. S. Don't write "You'll break company policy." and related, I'm asking from technical standpoint.

Given a clean install of a public distribution of Linux on your own computer, I should say that your employer can monitor  the activity you do with gmail suite, but not any other activity on your computer. That is, if you login to gmail suite your employer can track when you log in, when you log out, when you are reading document, writing documents, and either explicitly or implicitly when you are idle (not doing any work related activity).


Recover the password of a Windows service user login account When setting up a Windows service, one specifies a user account to use for authentication, as well as the password for that user. In their guidelines for user account selection, Microsoft states that when using a domain user account,

  Be aware that even though the service control manager (SCM) stores the password in a secure portion of the registry, it is nevertheless subject to attack.

They make no mention of what such an attack would look like. I assume that one would want to have administrative privileges on the OS hosting the service, and it would seem that the password is only used when the service is started, so that restarting it could play a role.

So, the question is: What does Microsoft mean when they say that a domain user's password is subject to attack? And, are there any substantial differences between the (more recent) versions of the OS?

One method to access LSA secrets is documented here.

In a nutshell:

Call the Enable-TSDuplicateToken function.
Copy the existing registry keys to another, temporary key.
User Powershell or another framework to call the functions to read the secrets.

You can also use the NirSoft LSASecretsView tool.

You do indeed have to already have admin privileges on the system, and as far as I know there are no differences in recent versions of Windows (other than the mitigations that McMatty already pointed out).


Uploading file with VPN...can they see my real ip? If I'm connected to a VPN, and I upload a file to a website from my computer via a system similar to this

Can they tell that I have uploaded it from my
real IP or will they see my VPN IP?

Thank you

Can they tell that I have uploaded it from my real IP or will they see my VPN IP?

Yes.

The connections should come from your VPN IP, if that type of traffic goes out across it.

They may also be able to tell your real IP if your browser runs their code and that code reveals other IPs.  As a single reference see http://www.wilderssecurity.com/threads/can-java-script-show-real-ip-address.223112/.

For a further remediation, try a TAILS LiveCD - read all the warnings on that site, too.


Based on cookies, does a website knows that a user visited it if the user does not log in? I, user ABC, have an account on some financial website example.com. I have logged in from my browser many times before so cookies were saved. Each time I would log off after I finish browsing that website.
The next time I arrive at the page, I am at the log-in page again. Now if I do not log in and simply browse around that website, does that website know that the user ABC has been poking around on the website without logging in, based on cookies?
I ask this because I use proxies to log into the website. Sometimes I use a U.S. proxy, another time a Singapore proxy, etc. However recently this site begins to "flag" non-US IP addresses. Log-in from non-US addresses will raise additional security questions, and activities inside the site, like money transfers, are restricted.
So if I stick to logging in to this site using US proxy, I think I should be fine. But what if from the same browser and cookies, I browse around this website WITHOUT proxy and WITHOUT logging in. Can this website flag my account based on cookies?

...  does that website know that the user ABC has been poking around on the website without logging in, based on cookies?

Cookies and other client-side stored information (i.e. cached pages, cached redirects, local storage ...) can be easily used to track a user over multiple visits, no matter if the user is logged in or not. If the user was logged in once these information than can also be associated with a specific user, so that it is possible to track future visits of this user even after logout. This does not mean that this is done though, but it is technically possible without the user being aware of it.

.... WITHOUT proxy and WITHOUT logging in ... Can this website flag my account based on cookies?

These information are stored locally at the client and are only associated with the target site. They are not associated with a specific way to access the target site, i.e. it also does not matter if a proxy or VPN is used or not or if the user is changing its location, changing the ISP etc. Thus the user can be tracked as long as the same browser on the same computer is used, independent from additional proxies, VPN etc.


Separation of duties for user account creation Are there any implementations (such as Active Directory) that have applied separation of duties to user account creation, which would require the create user account task and approval task to be done by two different users?

For example, if an administrator with the necessary privileges tries to create a user account, the administrator would not be able to proceed until the other user has approved it on the system.

In Active Directory this can be done with the help of third-party solutions that can provide approval-based workflow. Here's our solution that allows you to do that (it's a solution that we provide which illustrates the approach)

The operation can be sent for approval only if certain conditions are met (e.g. if the initiator is not a member of IT staff group).