/// <summary>
/// Mapping between SymmetricStreamAlgorithm enum representationa and String name
/// </summary>
/// <param name="symmetrcStreamAlgorithm">SymmetrcStreamAlgorithm enum, algorithm name</param>
/// <param name="error">Error type for error management</param>
/// <returns>String SymmetrcStreamAlgorithm name value</returns>
public static String valueOf(SymmetricStreamAlgorithm symmetrcStreamAlgorithm, Error error)
{
switch (symmetrcStreamAlgorithm)
{
case SymmetricStreamAlgorithm.RC4:
return("RC4");
case SymmetricStreamAlgorithm.HC128:
return("HC128");
case SymmetricStreamAlgorithm.HC256:
return("HC256");
case SymmetricStreamAlgorithm.CHACHA20:
return("CHACHA20");
case SymmetricStreamAlgorithm.SALSA20:
return("SALSA20");
case SymmetricStreamAlgorithm.XSALSA20:
return("XSALSA20");
case SymmetricStreamAlgorithm.ISAAC:
return("ISAAC");
case SymmetricStreamAlgorithm.VMPC:
return("VMPC");
default:
error.setError("SS002", "Unrecognized SymmetricStreamAlgorithm");
return("Unrecognized algorithm");
}
}
/// <summary>
/// Returns key size for the algorithm in bits
/// </summary>
/// <param name="algorithm">SymmetrcStreamAlgorithm enum, algorithm name</param>
/// <param name="error">Error type for error management</param>
/// <returns>array int with fixed length 3 with key, if array[0]=0 is range, else fixed values</returns>
public static int[] getKeySize(SymmetricStreamAlgorithm algorithm, Error error)
{
int[] keySize = new int[3];
switch (algorithm)
{
case SymmetricStreamAlgorithm.RC4:
keySize[0] = 0;
keySize[1] = 40;
keySize[2] = 2048;
break;
case SymmetricStreamAlgorithm.HC128:
keySize[0] = 1;
keySize[1] = 128;
break;
case SymmetricStreamAlgorithm.HC256:
case SymmetricStreamAlgorithm.XSALSA20:
keySize[0] = 1;
keySize[1] = 256;
break;
case SymmetricStreamAlgorithm.CHACHA20:
case SymmetricStreamAlgorithm.SALSA20:
keySize[0] = 1;
keySize[1] = 128;
keySize[2] = 256;
break;
case SymmetricStreamAlgorithm.ISAAC:
keySize[0] = 0;
keySize[1] = 32;
keySize[2] = 8192;
break;
case SymmetricStreamAlgorithm.VMPC:
keySize[0] = 0;
keySize[1] = 8;
keySize[2] = 6144;
break;
default:
error.setError("SS003", "Unrecognized SymmetricStreamAlgorithm");
break;
}
return(keySize);
}
/********EXTERNAL OBJECT PUBLIC METHODS - END ********/
/// <summary>
/// Buils the StreamCipher
/// </summary>
/// <param name="algorithm">SymmetrcStreamAlgorithm enum, algorithm name</param>
/// <returns>IStreamCipher with the algorithm Stream Engine</returns>
private IStreamCipher getCipherEngine(SymmetricStreamAlgorithm algorithm)
{
IStreamCipher engine = null;
switch (algorithm)
{
case SymmetricStreamAlgorithm.RC4:
engine = new RC4Engine();
break;
case SymmetricStreamAlgorithm.HC128:
engine = new HC128Engine();
break;
case SymmetricStreamAlgorithm.HC256:
engine = new HC256Engine();
break;
case SymmetricStreamAlgorithm.SALSA20:
engine = new Salsa20Engine();
break;
case SymmetricStreamAlgorithm.CHACHA20:
engine = new ChaChaEngine();
break;
case SymmetricStreamAlgorithm.XSALSA20:
engine = new XSalsa20Engine();
break;
case SymmetricStreamAlgorithm.ISAAC:
engine = new IsaacEngine();
break;
case SymmetricStreamAlgorithm.VMPC:
engine = new VmpcEngine();
break;
default:
this.GetError().setError("SS005", "Cipher " + algorithm + " not recognised.");
break;
}
return(engine);
}
/// <summary>
/// Containsinformation about algorithm's IV
/// </summary>
/// <param name="algorithm">SymmetrcStreamAlgorithm enum, algorithm name</param>
/// <param name="error">Error type for error management</param>
/// <returns>true if the algorithm uses an IV or nonce, false if it do not</returns>
internal static bool usesIV(SymmetricStreamAlgorithm algorithm, Error error)
{
switch (algorithm)
{
case SymmetricStreamAlgorithm.RC4:
case SymmetricStreamAlgorithm.HC128:
case SymmetricStreamAlgorithm.ISAAC:
return(false);
case SymmetricStreamAlgorithm.HC256:
case SymmetricStreamAlgorithm.SALSA20:
case SymmetricStreamAlgorithm.CHACHA20:
case SymmetricStreamAlgorithm.XSALSA20:
case SymmetricStreamAlgorithm.VMPC:
return(true);
default:
error.setError("SS007", "Unrecognized SymmetricStreamAlgorithm");
return(true);
}
}
public string DoEncrypt(string symmetricStreamAlgorithm, string key, string IV,
string plainText)
{
this.GetError().cleanError();
SymmetricStreamAlgorithm algorithm = SymmetricStreamAlgorithmUtils.getSymmetricStreamAlgorithm(symmetricStreamAlgorithm, this.GetError());
if (this.GetError().existsError())
{
return("");
}
IStreamCipher engine = getCipherEngine(algorithm);
if (this.GetError().existsError())
{
return("");
}
/* KeyParameter keyParam = new KeyParameter(Hex.Decode(key));
* engine.Init(true, keyParam);*/
byte[] keyBytes = SecurityUtils.GetHexa(key, "SS007", this.error);
byte[] ivBytes = SecurityUtils.GetHexa(IV, "SS007", this.error);
if (this.HasError())
{
return("");
}
KeyParameter keyParam = new KeyParameter(keyBytes);
if (SymmetricStreamAlgorithmUtils.usesIV(algorithm, this.GetError()))
{
if (!this.GetError().existsError())
{
ParametersWithIV keyParamWithIV = new ParametersWithIV(keyParam, ivBytes);
try
{
engine.Init(false, keyParamWithIV);
}catch (Exception e)
{
this.error.setError("SS008", e.Message);
return("");
}
}
}
else
{
try
{
engine.Init(false, keyParam);
}catch (Exception e)
{
this.error.setError("SS009", e.Message);
return("");
}
}
EncodingUtil eu = new EncodingUtil();
byte[] input = eu.getBytes(plainText);
if (eu.GetError().existsError())
{
this.error = eu.GetError();
return("");
}
byte[] output = new byte[input.Length];
engine.ProcessBytes(input, 0, input.Length, output, 0);
if (output == null || output.Length == 0)
{
this.GetError().setError("SS004", "Stream encryption exception");
return("");
}
this.GetError().cleanError();
return(Base64.ToBase64String(output));
}
