One of my d&d groups came up against a giant slug (a homebrew monster) today, and one player decreed they were going to toss salt at it (this time, it wasn’t me who suggested it). The GM asked where they got it from, and the player responded that they probably had it in their rations, just loose for seasoning.
The GM was skeptical, and asked me to look it up (I’m a player, but I tend to be the one who looks stuff up). The PHB definition of rations is:
Rations consist of dry foods suitable for extended travel, including jerky, dried fruit, hardtack, and nuts.
The player said that “including” means that that’s not the only stuff that’s in the rations, and that since salt is necessary for human health, it’s probably included in the rations. They also cited Roman armies sending soldiers with a salary, or salt money, just so they could buy salt.
The GM said that the salt would probably be in things such as hardtack or jerky, rather than just loose in the rations packet.
Is loose salt included in rations?
I have recently read an article about keeping passwords safely and I have a few misunderstandings. I found out 4 ways of storing users’ passwords: 1). Just keep them in plain text 2). Keep passwords in plain text, but encrypt the database 3). Hash a password 4). Use "salt hashing". Generate a random string and use a hashing algorithm after concatenation entered user’s password and randomly generated string. And I also have to store this string to let user in.
The best way was 4-th. Then my main misunderstanding is about: "what do we want to protect from?". As I understand – from the case when hacker gets access to our server and gets the database and the server-side source code. In this case I, as a developer, jeopardize accounts of those users, who have same passwords on all websites. Hacker gets a password from my database and then knows, what password does this user have on other websites/apps. That is why I want to to make passwords as secure as it is possible. In this case I do not understand the difference between ways 3 and 4 (1 and 2 are obviously bad, I think).
To crack passwords in way 3 the hacker gets my hashing algorithm and just tries to hash some passwords (either brute force or maybe some db of common passwords) and compare gotten string to the database. To crack way 4 the hacker has to try passwords like in the way 3, but, when hashing, his program will just take stored random string from my base and use it when hashing. It will be a bit longer for hacker, but not a lot (I think). So why the way 4 should be a lot more secure than the 3 one, or what do not I understand in the 4th way?
I’ve been having trouble with this certain salted MD5 hash, even though I know the salt, and I’ve been having trouble finding anywhere online that will crack salted MD5 hashes. All I’m finding is just straight MD5 only. Can anyone point me in the right direction? Preferrably something free or affordable.It’s in the md5(hash.salt) format.
Yes, I have tried using hashcat and crackstations wordlist to no avail.
I obtained a sha1 hash and a salt from a vulnerable pen testing machine, but i cant seem to crack it using hashcat 3.4.0 and online tools. Am i supposed to format the hash and the salt differently? Im currently using this format: Hash:salt
I was looking about how to salt a password in PowerShell, as SHA512 is not the safest way to store them, I want to add a salt to reduce bruteforcing.
Is there any way to add a salt to a password and then store it, to next at the moment ton authenticate use the appropiate salt?
I downloaded a software that has a login interface. It’s a $ 100 a month subscription software.
I disassembled the software and found that passwords are being sent by combining them with a hard coded “salt” that everyone can see in the source code (is it really “salt” if it’s the same for everyone?), encrypting them with MD5 and sending the hash to the server.
I hope that the passwords are encrypted again on the server side with unique salts to every user, but even if they do, isn’t this a breach? Can’t an attacker sniff the passwords easily, or do a send-the-hash attack?
I’m using a KDF (PBKDF2HMAC) to generate a Fernet key from a given password, but to do so I also need to generate and store a salt.
import base64 import os from cryptography.fernet import Fernet from cryptography.hazmat.backends imort default_backend from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC password = \"$ PASSWORD\" kdf = PBKDF2HMAC( algorithm=hashes.SHA256(),length=32,salt=\"$ FERNET_SALT\", iterations=100000,backend=default_backend() ) key = kdf.derive(password) key_encoded = base64.urlsafe_b64encode(key) print(key_encoded)
Due to technical constraints, it would be hugely convenient if I could generate that salt using AWS Secrets Manager, but it only generates strings with alphanumeric+punctuation.
So the question is if I could use these random strings as salt, even if they’re coming from a much smaller sample space than a typical
urandom would give. And if not, if I could somehow compress the given random string to achieve the necessary randomness.
I am designing a basic KMS based on a simple HSM, I only have access to: AES256, SHA256, PBKDF2, HMAC (and combinations like AES256-HMAC-SHA256). The admin and the users of the system have a personal HSM where the keys are stored and it works like this:
- The administrator generates a key inside his HSM with PBKDF2 (random salt and random seed)
- The HSM of the administrator encrypts the new key using AES-256 with a different symmetric key for each user (the key used for key wrapping was established during the physical initialization of the HSM of the user) and sends it to every user that needs it along with key’s metadata. The whole payload (encrypted key value + key’s metadata) is encrypted another time with AES256 with another unique key for each user.
- The payload reaches the user that, thanks to the two symmetric keys previously shared with the admin (during the HSM physical initialization), is able to retrieve the requested key and metadata.
I was thinking about another possible approach that could be better but I am not really sure about it:
- The administrator establishes a shared secret common to every user of the system. This secret is stored in every HSM belonging to the users or to the administrator.
- When a key must be generated, the administrator computes it with PBKDF2 using the common secret and a random salt.
- When a key must be sent to any user, only the salt that was used by the administrator is actually sent to the user. The salt may be encrypted with a pre-shared symmetric key (like the example above) and it is used by every user along with the shared secret to generate again the key.
The first approach has the following problems: I need to send the actual key value, I have to perform two encryptions, the HSM must offer an API to retrieve from its internal flash memory the actual value of a key (as cleartext or ciphertext depending on the choice of the caller, the API can be called only if the administrator is logged in the HSM and it can’t be called if the user is logged).
The second approach has the following problems: the secret is common to all users so if an attacker finds the secret of a single user, he founds the secret of everyone. The HSM must offer an API to retrieve the secret as cleartext from its internal flash memory because the secret must be the same for every user, even for users that are added to the system weeks/months later (again this API is callable only if the administrator is logged in the HSM).
I suppose that the second approach, in principle, could be better because the keys are not actually sent from the administrator to the users. But the secret common to everybody is a problem, moreover I imagine that if an attacker finds out the value of a random salt, he may simply try to compute all possible keys given that salt using PBKDF2 and all possible seeds (because the implementation is open source so he knows that the secret is 32 bytes long and he also has access to the PBKDF2 code).
In conclusion I think that in the real world the first approach is more secure, provided that the login as administrator to the HSM is protected by a very complex PIN and possibly by a second factor (i.e. fingerprint). Do you agree? Any thoughts about other vulnerabilities in my approach?
I have a very clever player that uses Prestidigitation for many useful things and one of the questions he asked me the other night is if he could use Prestidigitation to clean the salt out of the water. I wonder if water that has salt in it would be considered dirty. If I were to allow the cantrip to clean water in such a way am I forgetting another spell that would be tossed to the side because of this cantrip?
I was reading this post Is it safe/wise to store a salt in the same field as the hashed password?
$ argon2i$ v=19$ m=65536,t=3,p=1$ YOtX2//7NoD/owm8RZ8llw==$ fPn4sPgkFAuBJo3M3UzcGss3dJysxLJdPdvojRF20ZE=
For the string above, OP wrote:
“My understanding is that everything prior to p= are parameters, the body of the p= is the salt,
and the last part is the hashed password.”
the body of the p= is the salt : I am not getting this
body of ppart.
$ slices variant, version, parameters, salt and hash.
p (parallelism parameter) =
Am I correct in identifying salt and hash here?