/// <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)); }