I agree!!!
Printable View
I agree!!!
Might I add that there is a feature on this message board called Private Messaging ? ;)
Well, sorry, a moderator has to remind such things from time to time ;)
1. I am a Russian immigrant in the USA
2. I've lived here for less than 2 years
3. I wake up at 5:30 am
4. I take city bus at 6:45 and get to my college at 8:30
5. I take 20 credits at college, which are free (since I am a 15-year old Running Start student)
6. I stay at college until 6:00 p.m, study, do homework, classes, I don't have money for the lunch.
7. When I get home at about 8:30 - 9:00 p.m. I clean up the house, fix myself a dinner, and a breakfast.
8. I have about 1 hour for my own time, and I spend that hour learning C++ by a book, without having a computer at home.
9. I've been doing this for less than 2 years now (it's been Worse in Russia)
10. I take every single opportunity to hold on to my life, my GPA is 4.0 at the college.
It really hurts me, my heart, and my feelings to hear someone say that I am attempting to abuse my opportunity to access public resources like codeguru.com and ask for help at forums. I don't take any computer classes at college right now (but my major is computer science), since I also have to graduate from a High School.
And btw, I asked this specific question, because I was reading about encrypting algorithms, and I simply wanted to create my own. If you don't believe me, here's what I've been thinking of, of course don't take it seriously, I am just another 15 year old dumb kid trying to make something out of himself...
Quote:
SGCrypter - By Silver Ghost aka SG
I came up with idea on 10/26/02
NEW IDEA:
TESTING:
Starting out with string "Don't make me slap you foo! 10/26/02 Testing 0x15!"
1. String contains 50 characters (bytes).
2. The amount of digits in the key is the middle 10 bytes -> final_string = 50+10=60 bytes.
The first byte of those 10 is located by final_string/2
3. Suppose our key will have 10 digits => final_string = 60+10=70 bytes. This is final size:
" "
4. Locating the starting point of the amount of digits in the final_string: 70/2=35
5. Filling the string with the amount of digits:
" 0000000010 "
6. Calculating the position of the first byte of the key by a formula
if amount of digits in a key is even: pos = (pos_of_amount_of_digits(35)/2)-1
if amount of digits in a key is odd : pos = ((string_length*3/2) - (string_length*2/3))-_as_many_byes_that_it_goes_before_key_
7. Randomly generating a first byte of a key, but make sure, that
if it's odd: than position-that_byte >= 0 and != [randge of amount of digits] and != pos_of_any_other_byte
// since the next byte will be located at position-that_byte
if it's even: that position+that_byte < 70 and != [randge of amount of digits] and != pos_of_any_other_byte
// since the next byte will be located at position+that_byte
8. Position for the first byte is (35/2)-1 = 17-1 = 16 (see 6)
9. Randomly generated byte is 4 (satisfies all conditions of 7). String looks like:
" 4 0000000010 "
10. Next bytes position will be byte's_position+byte = 16+4 = 20
11. Randomly generating a byte. Say 9, which satifies all the conditions of 7. The string:
" 4 9 0000000010 "
12. Next bytes position will be byte's_position-byte(since odd) = 20 - 9 = 11
13. Randomly generating a byte. Say 1, which satisfies all the conditions of 7. The string:
" 1 4 9 0000000010 "
14. Next bytes position will be byte's_position-byte = 11-1 = 10
15. Randomly generating a byte. Say 6 - DOES NOT satisfy 7. Try 5 - works:
" 51 4 9 0000000010 "
16. Next bytes position will be byte's_position-byte(since odd) = 10 - 5 = 5
17. Randomly generating a byte. Say 8 - works:
" 8 51 4 9 0000000010 "
19. In the same way generating the rest of the bytes (already have 5):
6. 5+8 = 13 (pos); byte = 6, string:
" 8 51 6 4 9 0000000010 "
7. 13+6 = 19 (pos); byte = 8, string:
" 8 51 6 4 89 0000000010 "
8. 19+8 = 27 (pos); byte = 5, string:
" 8 51 6 4 89 5 0000000010 "
9. 27-5 = 22 (pos); byte = 3, no 5 - yes:
" 8 51 6 4 89 5 5 0000000010 "
10. 22-5 = 18; byte = 2 - yes ( since its the last byte - it don't have to satisfy 3rd condition of 7.
" 8 51 6 4 289 5 5 0000000010 "
20. Filling the final string with original one:
"Don't make me slap you foo! 10/26/02 Testing 0x15!" (original)
"Don'8t ma51k6e 4m289e5 sla5p you f0000000010oo! 10/26/02 Testing 0x15!" (final)
21. Key is: 4915868552
22. Reversign the key: 2558685194
22. Now we can jack all the bytes (except for the key bytes in an old-fashioned key-phasing.
IDEA:
Encryption - takes the string, creates a new one of size (old string + key_bytes),
where key_bytes is the length of the key ( 12345678 has a length of 8 ). Than it calculates
the position of the last byte of the key by a formula like
pos = (string_length*3/2) - (string_length*2/3)
After that, if that byte is even, than the next piece of key is + that byte (0-f), if the
byte is odd, than the next piece of key is is - that byte. For example, we recieve a line:
"Hi How Are You Doing? 123 helo!"(31 bytes) . Suppose we want to use a 3-digit key. The length
of a new string would be 31+3=34 byts. Than the position for the first element would be
34*3/2-34*2/3=11 . The byte is generated randomly, but we have to take in concern, that if
it's odd, it can't be more than 11, and if it's even, it can't be more than 34-11=23. Suppose
the generated key would be 5. The line now looks like:
" 5 "
We record the position of the byte (so that later we can't accidently put a new byte into
that place), and start calculating a new byte. Sice the first byte is odd, this one should
be in the 11-5=6th position in the string. Suppose a random generated byte is 8. The line will
look like this:
" 8 5 "
The next byte must be 6+8=14th position in the string. Suppose randomly generated byte is 3.
If our key was more than 3 digits, we wouldn't accept this number, since it'd point to the 11th
element which is already taken. But since it's the last element - we can accept it. The string
now looks like:
" 8 5 3 "
Now we can fill it with the old array:
"Hi Ho8w Ar5e 3You Doing? 123helo!"
They key is: 583. Now we reverse it: 385, and do the old type of encrypting for each element,
except each key element. Viola!