Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 10 years ago.
Improve this question
Lets suppose that we have the next string:
13:45:11:17:-65:107
This string is a product of RSA crypting. Each number is a byte of a crypted info.
We crypted it by a public key. After that we decide to "hide" it, the next way:
1=q,3=f,4=d,5=o,7=y,6=p,0=b,-=u,:=t;
and we have the next string, after all:
qftdotqqtqytupotqby
Supposing that server side will unhide this string by the reverse way. And decrypt by private key.
So i'm asking: if somebody steal this string, but he hasn't any access to our software. He has just a string - qftdotqqtqytupotqby
Is there possibility for him to understand that
qftdotqqtqytupotqby = 13:45:11:17:-65:107
If you make the assumption that the attacker cannot access your software and therefore all he has is some ECB (subsitution ciphered) encoded RSA crypttexts, than the answer is no he can't reverse it. (This assumes the RSA crypttexts are effectively byte-wise "pseudo random" without the secret key. If they have some plaintext predictable header information than the ECB could be attacked.)
This is however a very weak attacker position to be considering. In general you should assume an attacker has a copy of your software, otherwise every copy of your software is in effect a secret master key for the whole system.
I would favor using AES with a compiled in secret key to your homebrew ECB. At least that restricts the secret to the key and not potentially the whole software package. You could also use this technique to compartmentalize the security risk to just software packages with the same compiled in key.
From a strict security perspective, the letter coding is worthless and does not add any protection (see the Kerkhoff principle), since you cannot assume that the attacker does not know your implementation. The security must rest entirely in the key.
Assuming the RSA output really looks exactly as presented in the question (which implies that a ridiculously small RSA keysize was used), then it is easy to at least partly break the simple substitution because the ASCII representation of the RSA ciphertext is highly structured. The most frequent symbol will be the colon (:), while the symbol only appearing right next to a colon will be the minus (-). If there are four symbols between colons, the leftmost is the minus. If there are three symbols between colons, the leftmost is the minus, the one (1) or the two (2). There are 8 digits left which are not as easy, but combined with the small keysize of RSA which is used are no real obstacle.
The following is not directly part of the question, but have to be said as well: Whether the RSA part of your protocol is secure depends on so many factors that it is impossible to write a complete answer. Here just two examples of how the above scheme could be flawed:
The small block size of one byte implies a keysize of 8 bits, which is ridiculously easy to break even with only pen and paper.
If that's plain textbook RSA encryption without secure padding (such as PKCS#1 2.x OAEP), the scheme is fatally flawed. The attacker can simply use the public key to compute a dictionary with the encrypted versions of all 256 byte values and use the dictionary to decrypt all your encrypted bytes.
That being said, doing bytewise RSA is horribly inefficient, you are much better off putting all your bytes in a single RSA block, or if you have too much data for a single block, use a hybrid scheme with a symmetrical algorithm for bulk encryption and only RSA encrypt the random session key, as suggested by user1131467.
Related
So I've been studying this concept of length extension attacks and there are few things that I noticed during my study about it which are not very bright to me.
1.Research papers are explaining how you can append some type of data to the end and make newly formed data. For example
Desired New Data: count=10&lat=37.351&user_id=1&long=-119.827&waffle=eggo&waffle=liege
(notice 2 waffles). My question is if a parser function on the server side can track duplicate attributes, could then the entire length extension attack be nonsense? Because the server would notice duplicate attributes. Is a proper parser that is made to check any duplicates a good solution versus length extension attacks? I'm aware of HMAC approach and other protections, but specifically talking just about parsers here now.
2.Research says that only vulnerable data is H(key|message). They claim that H(message|key) won't work for the attacker because we would have to append a new key (which we obviously don't know). My question is why would we have to append a new key? We don't do it when we are attacking H(key|message). Why can't we rely on the fact that we will pass the verification test (we would create the correct hash) and that if the parser tries to extract the key from it, that it would take the only key in the block we send out and resume from there? Why would we have to send 2 keys? Why doesn't attack against H(message|key) work?
My question is if a parser function on server side can track duplicate attributes, could then the entire length extension attack be a nonsense?
You are talking about a well-written parser. Writing software is hard and writing correct software is very hard.
In that example, you have seen an overwritten attribute. Are you able to say that a good parser must take the last one or the first one? What is the rule? There can be stations that the last one must be taken! That is an attack that can be applied or not. This depends on the station. If you consider that the knowledge of the length extension attack goes back to 1990s, then finding a place applicable to this should amaze someone!. And, it is applied in the wild to Flickr API in 2009, after almost 20 years;
Flickr's API Signature Forgery by Thai Duong and Juliano Rizzo Published on Sep. 28, 2009.
My question is why would we have to append new key? We don't do it when we are attacking H(key|message). Why can't we relay on the fact that we will pass verification test (we would create correct hash) and that if parser tries to extract key from it, that it would take the only key in the block we send out and resume from there. Why would we have to send 2 keys? Why doesnt attack against H(message|key) work?
The attack is a signature forgery. The key is not known to the attacker, but they can still forge new signatures. The new message and signature - extended hash - is sent to the server, then the server takes the key and appends it to the message to execute a canonical verification, that is; if it does the signature is valid.
The parser doesn't extract the key, it already knows the key. The point is that can you make sure that the data is really extended or not. The padding rule is simple, add 1 and fill many zeroes so that the last 64 (128) is the length encoding (very simplified, for example, the final length must be multiple of 512 for SHA256). To see that there is another padding inside you must check every block and then you may claim that there is an extension attack. Yes, you can do this, however, the one of aims of cryptography is to reduce the dependencies, too. If we can create a better signature that eliminates the checking then we suggest to left the others. This enables the software developers to write more secure implementation easily.
Why doesn't attack against H(message|key) work?
Simple, you get the extended message message|extended and send the extended hash
H(message|key|extended) to the server. Then the server takes the message message|extended and appends the key message|extended|key and hashes it H(message|extended|key) and clearly this is not equal to the extended one H(message|key|extended)
Note that the trimmed version of the SHA2 series like SHA-512/256 has resistance to length extension attacks. SHA3 is immune to it by design and that enables a simple KMAC signature scheme. Blake2 is also immune since it is designed with the HAIFA construction.
This question already has answers here:
Difference between encoding and encryption
(11 answers)
Closed 9 years ago.
Could please someone explain me what is the difference between Encryption and Encoding? What are the scenarios you should use them and why?
The main difference between this two things is that encoding is converting something to something else that is well known and that is not a secret. For example, encoding some text to base64 to save memory and store data like that. When you use them, you will encode it back to string.
Encryption is, in fact, encoding data, but data that was decrypted - for security reasons.
Decryption should not be public - it means that only one with decryption key, could decrypt data.
Though the two might seem similar, what you wish to accomplish is the main difference.
Where encryption is used to seal the content of a file, so no others can read it, encoding is used for other means. Encryption mostly uses a password of passphrase of some sort.
For instance, if you compress a file with zip, you're encoding it. Everyone can just decode it, if they know the correct algorithm. However, if you compress the zip with a passphrase, it's encrypted as well.
Examples of encryption are:
SSL
Encrypted zip archives
...
Examples of encoding are:
Compression
Channel Coding (adding extra bits to data send across a channel so you can see if the arrived data is correct, ans possibly correct it if it wasn't)
...
Closed. This question is off-topic. It is not currently accepting answers.
Want to improve this question? Update the question so it's on-topic for Stack Overflow.
Closed 10 years ago.
Improve this question
can somebody explain this algorithm is secure or not? is there attack to break that? this algorithm uses common XOR cryptography but has some differences:
M(1) = key XOR Message(1)
M(2) = h(key) XOR Message(2)
M(3) = h(h(key)) XOR Message(3)
and so on
Notes:
M(i) is ciphered text
Message(i) is message that we are going to cipher it
key and Message(i) have the same lengths**
attacker just has the ciphered text and knows key making scheme(continues hashing) and XOR cryptography
hash algorithm is SHA-512
If the attacker ever gets to know a plaintext-ciphertext pair, he can calculate the corresponding key. And from that he can calculate all later keys. i.e. it's trivially vulnerable to a known plain text attack.
Note that when I say that the attacker guesses the message, I don't mean that he's sure that his guess is correct. He might make a few trillion guesses, and if one of them is correct, your whole scheme is broken.
And of course you must not ever reuse a key.
A more secure (but twice as slow) algorithm would be:
Key(i+1) = h("A"+key)
M(i) = h("B"+key) XOR Message(i)
Or a construction similar to CTR mode:
M(i) = h(i+key) XOR Message(i)
But I still wouldn't use either.
But there is no reason to use such a homebrew algorithm. There are plenty of existing algorithms that work well. For example if you like a stream cipher design, you could use AES in CTR mode.
Studying encryption algorithms is great fun. Just remember you are playing, not producing anything serious. As long as you are only keeping things like your personal diary (or maybe even passwords) encrypted and you keep the data secure, you will probably be fine. This kind of counts as security through obscurity. I would not recommend encrypting mass quantities of data that you REALLY need to keep private or anything that is available and of interest to the outside world, however.
In this case, if your message is shorter than the key size and hash block size and the key is single use and random, you are effectively using a one-use pad so everything in swell. Provided your random number key generation is perfect, you have an unbreakable encryption mechanism. As you add each block to the message, you are effectively calculating new keys using SHA-512, not adding any particular value. If an attacker can assume the message consists of printable text and if the length of the message is long or the key is used repeatedly, it should would not be too difficult to find the original key.
It would be more effective to calculate:
M(1)=h(N + key) XOR Message(1)
M(2)=h(M(1)) XOR Message(2)
M(3)=h(M(2)) XOR Message(3)
(where N is the number of times the key has been used which is passed in clear text.)
That way the bad guys can’t calculate your key sequence ahead of time and decrypt your message before you can. Also by using a salted hash of the key, the attacker won’t be able to predict the key sequence that will be used next time.
I read somewhere:
The first rule of cryptography is “Cryptography should be left to experts.”
The second rule is “You are not an expert.”
There is a reason people get PhDs in things like Computer Science and Mathematics. There is a lot to learn and discover. Something like this looks fine to me but no doubt it has a gaping hole that an attacker could drive a truck through.
Have fun and don't let grouchy people like me get you down.
/Bob Bryan
I'm looking to encrypt some data using multiple ciphers (ie, AES, Serpent, Twofish...), and I want the user to be able to choose which ciphers are used and in what order. Are there any standards available for defining the metadata? My understanding is that what I dont want to do is prefix each layer with a magic number indicating the type of cipher and parameters used in the next layer because it will expose me to a plaintext attack. I took a peak at the PKCS #8 RFC, and it appears that only a single layer of encryption is supported here:
EncryptedPrivateKeyInfo ::= SEQUENCE {
encryptionAlgorithm EncryptionAlgorithmIdentifier,
encryptedData EncryptedData }
I suppose I could just define the encryptionAlgorithm to be an array of values, but I want to make sure there isnt already a standard defined somewhere that I have missed.
PKCS#7 and its successor CMS allows for multiple layers. The EncryptedData contains an EncryptedContentInfo that when decrypted can contain another EncryptedData. This is usually used to combine encryption and signing, but there is no reason that it cannot be used for multiple layers of encryption (though support in other implementations may vary).
XML Encryption is another common standard for cryptographic metadata. It has no direct support for nesting encryption layers, but since it relies on the specification of the enclosing schema to specify the expected format of the encrypted data, there is no reason it could not specify multiple layers.
The OpenPGP Message Format is the final standardized format I can think of. Like CMS it supports nested layers of encryption (in theory - implementations might or might not support it).
Neither of the formats supports specifying nested encryption-layers upfront: the metadata for the nested layers will be encrypted, so you do not avoid the known-plaintext weakness. However, since you should always choose an algorithm that is safe against known-plaintext attacks anyway, I do not see that as a big problem.
Not that I'm aware of, because this isn't a cryptographic best-practice. Select a single, well known and peer reviewed cipher, and use that. Build your code so that you (or your users, rather) can easily swap out existing ciphers for a new one if a compromise is found, but don't expect to nest ciphers.
When I hear about methods for breaking encryption algorithms, I notice there is often focused on how to decrypt very rapidly and how to reduce the search space. However, I always wonder how you can recognize a successful decryption, and why this doesn't form a bottleneck. Or is it often assumed that a encrypted/decrypted pair is known?
From Cryptonomicon:
There is a compromise between the two
extremes of, on the one hand, not
knowing any of the plaintext at all,
and, on the other, knowing all of it.
In the Cryptonomicon that falls under
the heading of cribs. A crib is an
educated guess as to what words or
phrases might be present in the
message. For example if you were
decrypting German messages from World
War II, you might guess that the
plaintext included the phrase "HElL
HITLER" or "SIEG HElL." You might pick
out a sequence of ten characters at
random and say, "Let's assume that
this represented HEIL HITLER. If that
is the case, then what would it imply
about the remainder of the message?"
...
Sitting down in his office with the
fresh Arethusa intercepts, he went to
work, using FUNERAL as a crib: if this
group of seven letters decrypts to
FUNERAL, then what does the rest of
the message look like? Gibberish?
Okay, how about this group of seven
letters?
Generally, you have some idea of the format of the file you expect to result from the decryption, and most formats provide an easy way to identify them. For example, nearly all binary formats such as images, documents, zipfiles, etc, have easily identifiable headers, while text files will contain only ASCII, or only valid UTF-8 sequences.
In assymetric cryptography you usually have access to the public key. Therefore, any decryption of an encrypted ciphertext can be re-encrypted using the public key and compared to the original ciphertext, thus revealing if the decryption was succesful.
The same is true for symmetric encryption. If you think you have decrypted a cipher, you must also think that you have found the key. Therefore, you can use that key to encrypt your, presumably correct, decrypted text and see if the encrypted result is identical to the original ciphertext.
For symmetric encryption where the key length is shorter than the cipher-text length, you're guaranteed to not be able to produce every possible plain-text. You can probably guess what form your plain--text will take, to some degree -- you probably know whether it's an image, or XML, or if you don't even know that much then you can assume you'll be able to run file on it and not get 'data'. You have to hope that there are only a few keys which would give you even a vaguely sensible decryption and only one which matches the form you are looking for.
If you have a sample plain-text (or partial plain-text) then this gets a lot easier.