So no matter what anyone says about the rng the answer is always the same its random but as has been shown above rngs can be manipulated but instead of any decent replies it is just silly comments from the ussual people one of the reasons why so many people dont post on here they see the same group of players group together to attack any post they dont like.
I have not said skys rng is rigged/fixed nor have i accused the site of anything untoward just i seen this about rngs and thought i would share and hopefully someone who knows more about programing could reply and maybe explain it a bit better as from what i am reading rngs can be manipulated and if that is the case it is something anyone that plays poker online should be intrested in
There is a link to Help & Support on every single page of the Site, & this is what it says about the Random Number Generators they use;
"Sky Betting and Gaming's RNG is audited by the 3rd party company Technical Systems Testing (TST), who are global experts in the analysis of RNG's used for online gaming purposes. TST are approved by our regulators, the UK Gambling Commission and Alderney Gambling Control Commission, to conduct compliance testing".
There has never been a shred of evidence to suggest the RNG is not fit-for-purpose, & both TST & the 2 Regulators who oversee Sky Poker appear to be wholly satisfied.
This is it I'am not saying sky do anything wrong or untoward and if it has come accross that way i apoligise as it was not meant I only used the sky bingo site as that is where i seen this.
4.1 The software for Sky Bingo is powered by Virtue Fusion, who use a software-based Pseudo Random Number Generator (PRNG) developed by Sun Microsystems. The PRNG implements the SHA1PRNG algorithm, which is made available by the Java 2 Standard Edition 5 library class java.security.SecureRandom.
now after you read that and then go look at what is said about SHA1PRNG algoritham.
this comes up: TopBlend: Here is the first difference. There are 20 differences. is old. is new. java.security Class SecureRandom
java.lang.Object extended by java.util.Random extended by java.security.SecureRandom
All Implemented Interfaces: Serializable
public class SecureRandom extends Random
This class provides a cryptographically strong random number generator (RNG). Many implementations are in the form of a pseudo-random number generator (PRNG), which means they use a deterministic algorithm to produce a pseudo-random sequence from a true random seed. Other implementations may produce true random numbers and yet others may use a combination of both techniques. This class provides a cryptographically strong pseudo-random number generator (PRNG). A cryptographically strong pseudo-random number minimally complies with the statistical random number generator tests specified in FIPS 140-2, Security Requirements for Cryptographic Modules , section 4.9.1. Additionally, SecureRandom must produce non-deterministic output and therefore it is required that the seed material be unpredictable and that output of SecureRandom be cryptographically strong sequences as described in RFC 1750: Randomness Recommendations for Security .
A cryptographically strong random number minimally complies with the statistical random number generator tests specified in FIPS 140-2, Security Requirements for Cryptographic Modules , section 4.9.1. Additionally, SecureRandom must produce non-deterministic output and therefore it is required that the seed material be unpredictable and that output of SecureRandom be cryptographically strong sequences as described in RFC 1750: Randomness Recommendations for Security . Like other algorithm-based classes in Java Security, SecureRandom provides implementation-independent algorithms, whereby a caller (application code) requests a particular PRNG algorithm and is handed back a SecureRandom object for that algorithm. It is also possible, if desired, to request a particular algorithm from a particular provider. See the getInstance methods.
Like other algorithm-based classes in Java Security, SecureRandom provides implementation-independent algorithms, whereby a caller (application code) requests a particular RNG algorithm and is handed back a SecureRandom object for that algorithm. It is also possible, if desired, to request a particular algorithm from a particular provider. See the getInstance methods.
Thus, there are two ways to request a SecureRandom object: by specifying either just an algorithm name, or both an algorithm name and a package provider.
If just an algorithm name is specified, as in:
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
the system will determine if there is an implementation of the algorithm requested available in the environment, and if there is more than one, if there is a preferred one.
If both an algorithm name and a package provider are specified, as in:
SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
the system will determine if there is an implementation of the algorithm in the package requested, and throw an exception if there is not.
The SecureRandom implementation attempts to completely randomize the internal state of the generator itself unless the caller follows the call to a getInstance method with a call to the setSeed method:
SecureRandom random = SecureRandom.getInstance("SHA1PRNG"); random.setSeed(seed);
After the caller obtains the SecureRandom object from the getInstance call, it can call nextBytes to generate random bytes:
byte bytes[] = new byte[20]; random.nextBytes(bytes);
The caller may also invoke the generateSeed method to generate a given number of seed bytes (to seed other random number generators, for example):
byte seed[] = random.generateSeed(20);
See Also: SecureRandomSpi , Random , Serialized Form
Constructor Summary SecureRandom () By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation. SecureRandom (byte[] seed) By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation. protected SecureRandom ( SecureRandomSpi secureRandomSpi, Provider provider) Creates a SecureRandom object.
Method Summary byte[] generateSeed (int numBytes) Returns the given number of seed bytes, computed using the seed generation algorithm that this class uses to seed itself. String getAlgorithm () Returns the name of the algorithm implemented by this SecureRandom object. static SecureRandom getInstance ( String Generates a SecureRandom object that implements the specified Pseudo Random Number Generator (PRNG) algorithm. static SecureRandom getInstance getInstance ( String algorithm, Provider Generates a SecureRandom object that implements for the specified Random Number Generator (RNG) algorithm. PRNG algorithm, as supplied from the specified provider, if such a PRNG implementation is available from the provider. static SecureRandom getInstance getInstance ( String algorithm, Provider String Generates a SecureRandom object for the specified RNG PRNG algorithm, as supplied from the specified provider, if such a RNG PRNG implementation is available from the provider. static SecureRandom getInstance ( String algorithm, String Generates a SecureRandom object for the specified RNG algorithm, as supplied from the specified provider, if such a RNG implementation is available from the provider. Provider getProvider () Returns the provider of this SecureRandom object. static byte[] getSeed (int numBytes) Returns the given number of seed bytes, computed using the seed generation algorithm that this class uses to seed itself. protected int next (int numBits) Generates an integer containing the user-specified number of pseudo-random bits (right justified, with leading zeros). void nextBytes (byte[] bytes) Generates a user-specified number of random bytes. void setSeed (byte[] seed) Reseeds this random object. void setSeed (long seed) Reseeds this random object, using the eight bytes contained in the given long seed.
Methods inherited from class java.util. Random nextBoolean , nextDouble , nextFloat , nextGaussian , nextInt , nextInt , nextLong
By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation.
Note that this instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
This constructor is provided for backwards compatibility. The caller is encouraged to use one of the alternative getInstance methods to obtain a SecureRandom object.
By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation. This constructor uses a user-provided seed in preference to the self-seeding algorithm referred to in the empty constructor description. It may be preferable to the empty constructor if the caller has access to high-quality random bytes from some physical device (for example, a radiation detector or a noisy diode).
This constructor is provided for backwards compatibility. The caller is encouraged to use one of the alternative getInstance methods to obtain a SecureRandom object, and then to call the setSeed method to seed it.
Parameters: secureRandomSpi - the SecureRandom implementation. provider - the provider.
Method Detail getInstance
public static SecureRandom getInstance(String algorithm) throws NoSuchAlgorithmException
Generates a SecureRandom object that implements the specified Pseudo Random Number Generator (RNG) (PRNG) algorithm. If the default provider package provides an implementation of the requested algorithm, PRNG, an instance of SecureRandom containing that implementation is returned. If the algorithm PRNG is not available in the default package, other packages are searched.
Note that the returned instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
Parameters: algorithm - the name of the RNG PRNG algorithm. See Appendix A in the Java Cryptography Architecture API Specification & Reference for information about standard RNG PRNG algorithm names. Returns: the new SecureRandom object. Throws: NoSuchAlgorithmException - if the RNG PRNG algorithm is not available in the caller's environment. Since: 1.2
getInstance
public static SecureRandom getInstance(String algorithm, String provider) throws NoSuchAlgorithmException, NoSuchProviderException
Generates a SecureRandom object for the specified RNG PRNG algorithm, as supplied from the specified provider, if such a RNG PRNG implementation is available from the provider.
Note that the returned instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
Parameters: algorithm - the name of the RNG PRNG algorithm. See Appendix A in the Java Cryptography Architecture API Specification & Reference for information about standard RNG PRNG algorithm names. provider - the name of the provider. Returns: the new SecureRandom object. Throws: NoSuchAlgorithmException - if the requested RNG PRNG implementation is not available from the provider. NoSuchProviderException - if the provider has not been configured. IllegalArgumentException - if the provider name is null or empty. Since: 1.2 See Also: Provider
getInstance
public static SecureRandom getInstance(String algorithm, Provider provider) throws NoSuchAlgorithmException
Generates a SecureRandom object for the specified RNG PRNG algorithm, as supplied from the specified provider, if such a RNG PRNG implementation is available from the provider. Note: the provider doesn't have to be registered.
Note that the returned instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
Parameters: algorithm - the name of the RNG PRNG algorithm. See Appendix A in the Java Cryptography Architecture API Specification & Reference for information about standard RNG PRNG algorithm names. provider - the provider. Returns: the new SecureRandom object. Throws: NoSuchAlgorithmException - if the requested RNG PRNG implementation is not available from the provider. IllegalArgumentException - if the provider is null. Since: 1.4 See Also: Provider
getProvider
public final Provider getProvider()
Returns the provider of this SecureRandom object.
Returns: the provider of this SecureRandom object.
getAlgorithm
public StringgetAlgorithm ()
Returns the name of the algorithm implemented by this SecureRandom object.
Returns: the name of the algorithm or unknown if the algorithm name cannot be determined. Since: 1.5
setSeed
public void setSeed(byte[] seed)
Reseeds this random object. The given seed supplements, rather than replaces, the existing seed. Thus, repeated calls are guaranteed never to reduce randomness.
Parameters: seed - the seed. See Also: getSeed(int)
setSeed
public void setSeed(long seed)
Reseeds this random object, using the eight bytes contained in the given long seed. The given seed supplements, rather than replaces, the existing seed. Thus, repeated calls are guaranteed never to reduce randomness.
This method is defined for compatibility with java.util.Random.
Overrides: setSeed in class Random
Parameters: seed - the seed. See Also: getSeed(int)
nextBytes
public void nextBytes(byte[] bytes)
Generates a user-specified number of random bytes. This method is used as the basis of all random entities returned by this class (except seed bytes).
Overrides: nextBytes in class Random
Parameters: bytes - the array to be filled in with random bytes.
This method is only included for backwards compatibility. The caller is encouraged to use one of the alternative getInstance methods to obtain a SecureRandom object, and then call the generateSeed method to obtain seed bytes from that object.
Parameters: numBytes - the number of seed bytes to generate. Returns: the seed bytes. See Also: setSeed(byte[])
generateSeed
public byte[] generateSeed(int numBytes)
Returns the given number of seed bytes, computed using the seed generation algorithm that this class uses to seed itself. This call may be used to seed other random number generators.
Parameters: numBytes - the number of seed bytes to generate. Returns:
Now when you try read some of that makes you wonder about rngs all of them because if one can be manipulated and pre programed it brings into doubt the argument about rngs being random in nature because as has been shown before.
Any program by nature is programed by a human and as such is always liable to backdoors being added or faults being found as technoligy advances.
Instead of focusing on the thread being the rng is fixed maybe look at it as can a A rng be reprogramed/configured a certain way because as the stuff above says it can be and that is from sky bingos rng statement/faqs.
so what i take from that is virtual fusion uses a prng which can be preprogramed and can also be manipulated! as it says in the faqs about the shar1ping program that virtual fusion/sky use for the bingo site.
why if it is genuinley random does sky have the following in they're t&cs
4. Sky Bingo software and the Random Number Generator
4.1 The software for Sky Bingo is powered by Virtue Fusion, who use a software-based Pseudo Random Number Generator (PRNG) developed by Sun Microsystems. The PRNG implements the SHA1PRNG algorithm, which is made available by the Java 2 Standard Edition 5 library class java.security.SecureRandom.
Now mabye if some of the other 200 veiwers of this post commented and asked the same as me we would get a answer we could be confident in instead of the usual tin hat comments.
Rngs are supposedly random because thats the program they have but when you see the above comments on sky bingo saying virtual fusion use a prng it raises questions.
strange how i have shown for a fact(by fact meaning sky bingos own faqs) no false information that on sky bingos own site the random number generator might not be random afterall!
Now i have not insinutated skys rng might not be as random as claimed but sky bingo has infact pointed out this claim in they're own tacs
maybe someone in a programing background could comment on this would maybe help instead of the golden straw brigade
I think copy and pasting a load of industry speak text does nothing to further anyones understanding. From my reading of the parts I could follow It would appear some in the industry don't think the particular Sun system PRNG is as good as could be But nowhere is there reference to application, for example a formula one car is no use as a bus and Jac35 certainly doesn't need high performance golf clubs....... So in short a PRNG for Bingo or Poker may not need to stand up to the rigours of encryption in a security setting for example.
I didn’t read the mountain of text that Churchy posted in the hope someone could understand it for him. I assume in there somewhere was an apology to Tikay for being a knob on his last post?
"What's this fuss about true randomness? Perhaps you have wondered how predictable machines like computers can generate randomness. In reality, most random numbers used in computer programs are pseudo-random, which means they are generated in a predictable fashion using a mathematical formula. This is fine for many purposes, but it may not be random in the way you expect if you're used to dice rolls and lottery drawings.
RANDOM.ORG offers true random numbers to anyone on the Internet. The randomness comes from atmospheric noise, which for many purposes is better than the pseudo-random number algorithms typically used in computer programs."
Comments
This is it I'am not saying sky do anything wrong or untoward and if it has come accross that way i apoligise as it was not meant I only used the sky bingo site as that is where i seen this.
4.1 The software for Sky Bingo is powered by Virtue Fusion, who use a software-based Pseudo Random Number Generator (PRNG) developed by Sun Microsystems. The PRNG implements the SHA1PRNG algorithm, which is made available by the Java 2 Standard Edition 5 library class java.security.SecureRandom.
now after you read that and then go look at what is said about SHA1PRNG algoritham.
this comes up: TopBlend: Here is the first difference. There are 20 differences. is old. is new.
java.security
Class SecureRandom
java.lang.Object
extended by java.util.Random
extended by java.security.SecureRandom
All Implemented Interfaces:
Serializable
public class SecureRandom
extends Random
This class provides a cryptographically strong random number generator (RNG). Many implementations are in the form of a pseudo-random number generator (PRNG), which means they use a deterministic algorithm to produce a pseudo-random sequence from a true random seed. Other implementations may produce true random numbers and yet others may use a combination of both techniques. This class provides a cryptographically strong pseudo-random number generator (PRNG). A cryptographically strong pseudo-random number minimally complies with the statistical random number generator tests specified in FIPS 140-2, Security Requirements for Cryptographic Modules , section 4.9.1. Additionally, SecureRandom must produce non-deterministic output and therefore it is required that the seed material be unpredictable and that output of SecureRandom be cryptographically strong sequences as described in RFC 1750: Randomness Recommendations for Security .
A cryptographically strong random number minimally complies with the statistical random number generator tests specified in FIPS 140-2, Security Requirements for Cryptographic Modules , section 4.9.1. Additionally, SecureRandom must produce non-deterministic output and therefore it is required that the seed material be unpredictable and that output of SecureRandom be cryptographically strong sequences as described in RFC 1750: Randomness Recommendations for Security . Like other algorithm-based classes in Java Security, SecureRandom provides implementation-independent algorithms, whereby a caller (application code) requests a particular PRNG algorithm and is handed back a SecureRandom object for that algorithm. It is also possible, if desired, to request a particular algorithm from a particular provider. See the getInstance methods.
Like other algorithm-based classes in Java Security, SecureRandom provides implementation-independent algorithms, whereby a caller (application code) requests a particular RNG algorithm and is handed back a SecureRandom object for that algorithm. It is also possible, if desired, to request a particular algorithm from a particular provider. See the getInstance methods.
Thus, there are two ways to request a SecureRandom object: by specifying either just an algorithm name, or both an algorithm name and a package provider.
If just an algorithm name is specified, as in:
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
the system will determine if there is an implementation of the algorithm requested available in the environment, and if there is more than one, if there is a preferred one.
If both an algorithm name and a package provider are specified, as in:
SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
the system will determine if there is an implementation of the algorithm in the package requested, and throw an exception if there is not.
The SecureRandom implementation attempts to completely randomize the internal state of the generator itself unless the caller follows the call to a getInstance method with a call to the setSeed method:
SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
random.setSeed(seed);
byte bytes[] = new byte[20];
random.nextBytes(bytes);
The caller may also invoke the generateSeed method to generate a given number of seed bytes (to seed other random number generators, for example):
byte seed[] = random.generateSeed(20);
See Also:
SecureRandomSpi , Random , Serialized Form
Constructor Summary
SecureRandom ()
By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation.
SecureRandom (byte[] seed)
By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation.
protected SecureRandom ( SecureRandomSpi secureRandomSpi, Provider provider)
Creates a SecureRandom object.
Method Summary
byte[] generateSeed (int numBytes)
Returns the given number of seed bytes, computed using the seed generation algorithm that this class uses to seed itself.
String getAlgorithm ()
Returns the name of the algorithm implemented by this SecureRandom object.
static SecureRandom getInstance ( String
Generates a SecureRandom object that implements the specified Pseudo Random Number Generator (PRNG) algorithm.
static SecureRandom getInstance getInstance ( String algorithm, Provider
Generates a SecureRandom object that implements for the specified Random Number Generator (RNG) algorithm. PRNG algorithm, as supplied from the specified provider, if such a PRNG implementation is available from the provider.
static SecureRandom getInstance getInstance ( String algorithm, Provider String
Generates a SecureRandom object for the specified RNG PRNG algorithm, as supplied from the specified provider, if such a RNG PRNG implementation is available from the provider.
static SecureRandom getInstance ( String algorithm, String
Generates a SecureRandom object for the specified RNG algorithm, as supplied from the specified provider, if such a RNG implementation is available from the provider.
Provider getProvider ()
Returns the provider of this SecureRandom object.
static byte[] getSeed (int numBytes)
Returns the given number of seed bytes, computed using the seed generation algorithm that this class uses to seed itself.
protected int next (int numBits)
Generates an integer containing the user-specified number of pseudo-random bits (right justified, with leading zeros).
void nextBytes (byte[] bytes)
Generates a user-specified number of random bytes.
void setSeed (byte[] seed)
Reseeds this random object.
void setSeed (long seed)
Reseeds this random object, using the eight bytes contained in the given long seed.
Methods inherited from class java.util. Random
nextBoolean , nextDouble , nextFloat , nextGaussian , nextInt , nextInt , nextLong
Methods inherited from class java.lang. Object
clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait
Constructor Detail
SecureRandom
public SecureRandom()
By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation.
Note that this instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
This constructor is provided for backwards compatibility. The caller is encouraged to use one of the alternative getInstance methods to obtain a SecureRandom object.
public SecureRandom(byte[] seed)
By using this constructor, the caller obtains a SecureRandom object containing the implementation from the highest-priority installed provider that has a SecureRandom implementation. This constructor uses a user-provided seed in preference to the self-seeding algorithm referred to in the empty constructor description. It may be preferable to the empty constructor if the caller has access to high-quality random bytes from some physical device (for example, a radiation detector or a noisy diode).
This constructor is provided for backwards compatibility. The caller is encouraged to use one of the alternative getInstance methods to obtain a SecureRandom object, and then to call the setSeed method to seed it.
Parameters:
seed - the seed.
SecureRandom
protected SecureRandom(SecureRandomSpi secureRandomSpi,
Provider provider)
Creates a SecureRandom object.
Parameters:
secureRandomSpi - the SecureRandom implementation.
provider - the provider.
Method Detail
getInstance
public static SecureRandom getInstance(String algorithm)
throws NoSuchAlgorithmException
Generates a SecureRandom object that implements the specified Pseudo Random Number Generator (RNG) (PRNG) algorithm. If the default provider package provides an implementation of the requested algorithm, PRNG, an instance of SecureRandom containing that implementation is returned. If the algorithm PRNG is not available in the default package, other packages are searched.
Note that the returned instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
Parameters:
algorithm - the name of the RNG PRNG algorithm. See Appendix A in the Java Cryptography Architecture API Specification & Reference for information about standard RNG PRNG algorithm names.
Returns:
the new SecureRandom object.
Throws:
NoSuchAlgorithmException - if the RNG PRNG algorithm is not available in the caller's environment.
Since:
1.2
getInstance
public static SecureRandom getInstance(String algorithm,
String provider)
throws NoSuchAlgorithmException,
NoSuchProviderException
Generates a SecureRandom object for the specified RNG PRNG algorithm, as supplied from the specified provider, if such a RNG PRNG implementation is available from the provider.
Note that the returned instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
Parameters:
algorithm - the name of the RNG PRNG algorithm. See Appendix A in the Java Cryptography Architecture API Specification & Reference for information about standard RNG PRNG algorithm names.
provider - the name of the provider.
Returns:
the new SecureRandom object.
Throws:
NoSuchAlgorithmException - if the requested RNG PRNG implementation is not available from the provider.
NoSuchProviderException - if the provider has not been configured.
IllegalArgumentException - if the provider name is null or empty.
Since:
1.2
See Also:
Provider
getInstance
public static SecureRandom getInstance(String algorithm,
Provider provider)
throws NoSuchAlgorithmException
Generates a SecureRandom object for the specified RNG PRNG algorithm, as supplied from the specified provider, if such a RNG PRNG implementation is available from the provider. Note: the provider doesn't have to be registered.
Note that the returned instance of SecureRandom has not been seeded. A call to the setSeed method will seed the SecureRandom object. If a call is not made to setSeed, the first call to the nextBytes method will force the SecureRandom object to seed itself.
Parameters:
algorithm - the name of the RNG PRNG algorithm. See Appendix A in the Java Cryptography Architecture API Specification & Reference for information about standard RNG PRNG algorithm names.
provider - the provider.
Returns:
the new SecureRandom object.
Throws:
NoSuchAlgorithmException - if the requested RNG PRNG implementation is not available from the provider.
IllegalArgumentException - if the provider is null.
Since:
1.4
See Also:
Provider
getProvider
public final Provider getProvider()
Returns the provider of this SecureRandom object.
Returns:
the provider of this SecureRandom object.
getAlgorithm
public StringgetAlgorithm ()
Returns the name of the algorithm implemented by this SecureRandom object.
Returns:
the name of the algorithm or unknown if the algorithm name cannot be determined.
Since:
1.5
setSeed
public void setSeed(byte[] seed)
Reseeds this random object. The given seed supplements, rather than replaces, the existing seed. Thus, repeated calls are guaranteed never to reduce randomness.
Parameters:
seed - the seed.
See Also:
getSeed(int)
setSeed
public void setSeed(long seed)
Reseeds this random object, using the eight bytes contained in the given long seed. The given seed supplements, rather than replaces, the existing seed. Thus, repeated calls are guaranteed never to reduce randomness.
This method is defined for compatibility with java.util.Random.
Overrides:
setSeed in class Random
Parameters:
seed - the seed.
See Also:
getSeed(int)
nextBytes
public void nextBytes(byte[] bytes)
Generates a user-specified number of random bytes. This method is used as the basis of all random entities returned by this class (except seed bytes).
Overrides:
nextBytes in class Random
Parameters:
bytes - the array to be filled in with random bytes.
next
Parameters:
numBytes - the number of seed bytes to generate.
Returns:
the seed bytes.
See Also:
setSeed(byte[])
generateSeed
public byte[] generateSeed(int numBytes)
Returns the given number of seed bytes, computed using the seed generation algorithm that this class uses to seed itself. This call may be used to seed other random number generators.
Parameters:
numBytes - the number of seed bytes to generate.
Returns:
Now when you try read some of that makes you wonder about rngs all of them because if one can be manipulated and pre programed it brings into doubt the argument about rngs being random in nature because as has been shown before.
Any program by nature is programed by a human and as such is always liable to backdoors being added or faults being found as technoligy advances.
Instead of focusing on the thread being the rng is fixed maybe look at it as can a A rng be reprogramed/configured a certain way because as the stuff above says it can be and that is from sky bingos rng statement/faqs.
so what i take from that is virtual fusion uses a prng which can be preprogramed and can also be manipulated! as it says in the faqs about the shar1ping program that virtual fusion/sky use for the bingo site.
why if it is genuinley random does sky have the following in they're t&cs
https://support.skybingo.com/s/article/Sky-Bingo-Game-Rules
4. Sky Bingo software and the Random Number Generator
4.1 The software for Sky Bingo is powered by Virtue Fusion, who use a software-based Pseudo Random Number Generator (PRNG) developed by Sun Microsystems. The PRNG implements the SHA1PRNG algorithm, which is made available by the Java 2 Standard Edition 5 library class java.security.SecureRandom.
Now mabye if some of the other 200 veiwers of this post commented and asked the same as me we would get a answer we could be confident in instead of the usual tin hat comments.
Rngs are supposedly random because thats the program they have but when you see the above comments on sky bingo saying virtual fusion use a prng it raises questions.
strange how i have shown for a fact(by fact meaning sky bingos own faqs) no false information that on sky bingos own site the random number generator might not be random afterall!
Now i have not insinutated skys rng might not be as random as claimed but sky bingo has infact pointed out this claim in they're own tacs
maybe someone in a programing background could comment on this would maybe help instead of the golden straw brigade
Have we untwisted our knickers from a few weeks ago?
From my reading of the parts I could follow It would appear some in the industry don't think the particular Sun system PRNG is as good as could be
But nowhere is there reference to application, for example a formula one car is no use as a bus and Jac35 certainly doesn't need high performance golf clubs.......
So in short a PRNG for Bingo or Poker may not need to stand up to the rigours of encryption in a security setting for example.
I assume in there somewhere was an apology to Tikay for being a knob on his last post?
Perhaps you have wondered how predictable machines like computers can generate randomness. In reality, most random numbers used in computer programs are pseudo-random, which means they are generated in a predictable fashion using a mathematical formula. This is fine for many purposes, but it may not be random in the way you expect if you're used to dice rolls and lottery drawings.
RANDOM.ORG offers true random numbers to anyone on the Internet. The randomness comes from atmospheric noise, which for many purposes is better than the pseudo-random number algorithms typically used in computer programs."