kemi írta/wrote:
Meg valami pécén "ehető" formátumra gondoltam,

kemi írta/wrote:
de már egy 9 kB-os fájlnál is rohadt lassú a valódi véletlengenerátor miatt.

kemi írta/wrote:
Átírtam az RC-t is, hogy legyen már egy natív linuxos progink is.

	*= $0801
	.byte $54,$43,$48,$00,$9E,$32,$30,$36,$31,$00,$00,$00
	LDA #$0
	STA $D011
kecske	LDA #0
	STA $D020
	LDY #0
-	LDA $D012
	CMP sorok,Y
	BNE -
	LDA szinek,Y
	STA $D020
	INY
	LDA szinek,Y
	CMP #$FF
	BNE -
	JMP kecske
szinek	.byte 002,010,001,010,002,000,005,013,001,013,005,000,006,014,001,014,006,000,255
sorok	.byte 100,101,102,103,104,105,110,111,112,113,114,115,120,121,122,123,124,125

TCH írta/wrote:
Miért? Mi a valódi véletlengenerátor kódja?

TCH írta/wrote:
Van. Az oscompon több is fel van pakolva.

kemi írta/wrote:
A /dev/random-ból olvas ki.

kemi írta/wrote:
Itt nem nagyon van. Ha ez egy windózfikázó oldal ne már csak winfos programok legyenek fent.

kemi írta/wrote:
"Folytassa a rendszerindító menuné'."

Windows 8 is the next version of MS-DOS, a family of donkeys produced by The Walt Disney Company for use on tractors

TCH írta/wrote:
Megmutatod a kódot?

FILE* infile = fopen(argv[2], "r");
FILE* rnd = fopen("/dev/random", "r");
FILE* outfile = fopen(argv[3], "w");
FILE* keyfile = fopen(argv[4], "w");
int b;
int c;
while ((b = fgetc(infile)) != EOF) {
  c = fgetc(rnd);
  fputc(b ^ c, outfile);
  fputc(c, keyfile);
}

TCH írta/wrote:
Sebaj, az angol verzió nyitottabb, szal a winnyóc cikke most így kezdődik:

Windows 8 is the next version of MS-DOS, a family of donkeys produced by The Walt Disney Company for use on tractorss

He-he.

kemi írta/wrote:
A visszafejtés gyors egy nagyobb fájlnál is, de a kódolás 5 percig elszunnyog egy 10 kB-os fájl esetén.

"Akkorat gitteltem nem ment le, kiontott a budi mire a kefet felkaptam... Es ahogy tunkoltam megjobban kilocsogott. Neked, hogy telik a nap?"

TCH írta/wrote:
csinálnék egy valamekkora puffert és abba blockreaddal berántanék a /dev/randomból egy adagot.

TCH írta/wrote:
vagyis a kulcs kérdését nem sikerült kiküszöbölni.

kemi írta/wrote:
Megpróbálom, csak hát itt az a kritikus, hogy a /dev/random milyen sebességgel állítja elő a random számokat. Így a puffer is addig vár, amíg a /dev/random ki nem dob egy bájtot.

kemi írta/wrote:
Arra jó, ha mondjuk egy gúgli tárhelyre fel akarsz tölteni valamit, de nem akarod, hogy a gúgli vagy bárki más belelásson, a kulcsot meg csak a saját gépeden tárolod. A hátulütő viszont, hogy egy 100 megás fájlhoz 100 megás kulcs lesz. (az más kérdés, hogy 8 óra mire eltitkosítja. :P)

kemi írta/wrote:
Megpróbáltam úgy, hogy nem bájtonként, hanem longonként (8 bájt) olvas, de nem sokkal gyorsabb. Mondom itt a /dev/random lassú.

kemi írta/wrote:
Ha az RC annyira jó titkosító algoritmus lenne, már rég az RSA-nál dolgoznánk.

kemi írta/wrote:Mellesleg nem hiszem, hogy mondjuk az USA kormányát, akik államtitkokat szeretnének elkódolni, érdekelné, hogy baromi lassú. Max rábízzák egy szuperszámítógépre.

Procedure rnd8232encrypt(ptr0: ^Byte; ptr1: ^Longword; size, key: Longword);
var
	i: Longword;
	offset, value: Byte;
Begin
	RandSeed := key;
	i := 1;
	For i := 1 To size Do
	Begin
		offset := Random And 31;
		value := ptr0^;
		ptr1^ := Random Xor ((value shl offset) Or (value shr (32 - offset)));
	End;
End;

Procedure rnd8232decrypt(ptr0: ^Longword; ptr1: ^Byte; size, key: Longword);
var
	i, value: Longword;
	offset: Byte;
Begin
	RandSeed := key;
	i := 1;
	For i := 1 To size Do
	Begin
		offset := Random And 31;
		value := ptr0^ Xor Random;
		ptr1^ := ((value shr offset) Or (value shl (32 - offset)));
	End;
End;

TCH írta/wrote:
az USA garantáltan nem fog úgy elkódolni valamit, hogy ahhoz kelljen egy ugyanakkora kulcs, mint az adat maga, pláne nem kell nekik olyan kódoló eljárás, ami nyomot (vö. kulcsot) hagy maga után.

Wikipedia írta/wrote:
For such applications as cryptography, the use of pseudorandom number generators (whether hardware or software or some combination) is insecure. When random values are required in cryptography, the goal is to make a message as hard to crack as possible, by eliminating or obscuring the parameters used to encrypt the message (the key) from the message itself or from the context in which it is carried. Pseudorandom sequences are deterministic and reproducible; all that is required in order to discover and reproduce a pseudorandom sequence is the algorithm used to generate it and the initial seed. So the entire sequence of numbers is only as powerful as the randomly chosen parts - sometimes the algorithm and the seed, but usually only the seed.
There are many examples in cryptographic history of cyphers, otherwise excellent, in which random choices were not random enough and security was lost as a direct consequence. The World War II Japanese PURPLE cypher machine used for diplomatic communications is a good example. It was consistently broken throughout WWII, mostly because the "key values" used were insufficiently random. They had patterns, and those patterns made any intercepted traffic readily decryptable. Had the keys (i. e., the initial settings of the stepping switches in the machine) been made unpredictably (i.e., randomly), that traffic would have been much harder to break, and perhaps even secure in practice.
Users and designers of cryptography are strongly cautioned to treat their randomness needs with the utmost care. Absolutely nothing has changed with the era of computerized cryptography, except that patterns in pseudorandom data are easier to discover than ever before. Randomness is, if anything, more important than ever.

kemi írta/wrote:
Az RC, meg ha van mondjuk egy 64 bites kulcs, akkor ugye brute force-szal a támadónak átlagosan 2⁶⁴ / 2 lehetséges seedet kell végigpróbálnia. Elég nagy szám, de máris nem törhetetlen.

kemi írta/wrote:
Ha viszont többször több irányba lett elkódolva akkor már nehezebb a dolga.

unsigned int __seed;

unsigned int rol(unsigned int value)
{
	return (value << 1) | (value >> 31);
}

unsigned int ror(unsigned int value)
{
	return (value >> 1) | (value << 31);
}

unsigned int rnd()
{
	unsigned int x, y, i;
	x = __seed;
	y = ~__seed;
	for (i = 0; i < 31; ++i)
	{
		x = rol(x);
		y = ror(y);
		__seed ^= x;
		__seed ^= y;
	}
	return __seed;
}

__rnd	move.l __seed, d0
	move.l d0, d1
	move.l d1, d2
	not.l d2
	moveq #32, d3
-	rol.l #1, d1
	ror.l #1, d2
	eor.l d1, d0
	eor.l d2, d0
	dbra d3, -
	move.l d0, __seed
	rts
__seed	dc.l 0