Do these 2 KSA shortcuts weaken RC4? Alice securely gives Bob a secret key so they can exchange 10 different messages encrypted with RC4.  (Messages will include a counter for uniqueness and a MAC for authentication.)  For each message exchange, Alice and Bob both start by permuting the standard byte array using the secret key (ie, the "KSA" key-scheduling algorithm, per Wikipedia):

for i from 0 to 255
    S[i] := i
endfor
j := 0
for i from 0 to 255
    j := (j + S[i] + key[i mod keylength]) mod 256
    swap values of S[i] and S[j]
endfor


At this point, Alice and Bob have each computed identical S[] arrays, and the secret key is no longer used by subsequent RC4 steps.

Shortcut 1:  Alice decides that instead of securely sending Bob the secret key and making him do the KSA step for every message exchange, she'll compute the S[] array, securely send him the 256-byte array instead of the secret key to begin with, and from then on each time they need to encrypt/decrypt they'll both skip the KSA step to save time and just start with Alice's precomputed S[] array.

Shortcut 2:  After using the above algorithm to compute the initial S[] array she had planned to send to Bob instead of the secret key, Alice realizes the KSA step seems to basically just want to scramble the S[] array.  So instead of scrambling the array based on a key, she relies on the operating system random() function and just computes...

for i from 0 to 255
    S[i] := i
endfor
for i from 0 to 255
    swap(S[i], S[random(0..255)]) // swap S[i] with some arbitrary S[]
endfor


...and securely sends Bob her "randomly" scrambled array that doesn't even use a key.

Do those 2 shortcuts weaken RC4?
The obvious problem with Shortcut 1 is that the same keystream will be used to encrypt all the messages.  That is, an attacker can exclusive-or two ciphertexts together, and the result will be the exclusive-or of the two plaintexts; this may very well allow the attacker to recover both messages.  How easy this is depends on the language the messages are in; if we assume they are in ASCII-English, this is fairly straight-forwarding as long as the messages aren't extremely brief.

There are two obvious problems with Shortcut 2:


How cryptographically secure is the operating system "random" function?  Quite often, such operating system functions are only statistically random, this might not be good enough.
You say that Alice "securely" sends Bob the array; is she sending a separate array for each message?  If so, why doesn't she use that secure method to send the message?  If not (that is, she reused the same array for different messages), she runs into exactly the same problem as Shortcut 1.


Also, in shortcut 2, your pseudocode says "Assign a random S[] element to S[i]", while your comment says to swap them.  Which do you mean?  What you really want to do is swap the elements (it's important that S[] remain a permutation).