public void testRandPrim512() { for(int i = 0; i < cycles; i++) { BigInteger bigPrime = new BigInteger (big512,1,secRand); } }
public void testEncryptBlock() { for (int i = 0; i < cycles; i++) { BigInteger nBig = new BigInteger (nVal); encBlock = encryptBlock (data, nBig); } }
public void testRandPrim2048() { for(int i = 0; i < cycles; i++) { BigInteger bigPrime = new BigInteger (big2048,5,secRand); } }
/// <summary>Generate a prime number with half size of keyBitSize</summary> public void run() { do { prime = new BigInteger(halfKeyBitSize - 1, 1, scRandom); } while (!(core.getPrimetest().isPrime(prime)) || prime.toByteArray().Length != keyByteSize); }
public void testDecryptBlock() { for (int i = 0; i < cycles; i++) { BigInteger nBig = new BigInteger (nVal); BigInteger dBig = new BigInteger (dVal); decBlock = decryptBlock (encBlock,nBig,dBig); } }
// Expected tree for function: ^(FUNC ID ( INT | ID ) expr) /** Set up a local evaluator for a nested function call. The evaluator gets the definition * tree of the function; the set of all defined functions (to find locally called ones); a * pointer to the global variable memory; and the value of the function parameter to be * added to the local memory. */ private ProfileTreeGrammar( CommonTree function, List<CommonTree> functionDefinitions, IDictionary<string, BigInteger> globalMemory, BigInteger paramValue ) : this(new CommonTreeNodeStream( function.GetChild( 2 ) ), functionDefinitions) { this.globalMemory = globalMemory; localMemory[function.GetChild( 1 ).Text] = paramValue; }
/** Set up a local evaluator for a nested function call. The evaluator gets the definition * tree of the function; the set of all defined functions (to find locally called ones); a * pointer to the global variable memory; and the value of the function parameter to be * added to the local memory. */ private DebugTreeGrammar(CommonTree function, List <CommonTree> functionDefinitions, IDictionary <string, BigInteger> globalMemory, BigInteger paramValue) // Expected tree for function: ^(FUNC ID ( INT | ID ) expr) : this(new CommonTreeNodeStream(function.GetChild(2)), functionDefinitions) { this.globalMemory = globalMemory; localMemory[function.GetChild(1).Text] = paramValue; }
/** Set up a local evaluator for a nested function call. The evaluator gets the definition * tree of the function; the set of all defined functions (to find locally called ones); a * pointer to the global variable memory; and the value of the function parameter to be * added to the local memory. */ private DebugTreeGrammar( CommonTree function, List<CommonTree> functionDefinitions, IDictionary<string, BigInteger> globalMemory, BigInteger paramValue ) // Expected tree for function: ^(FUNC ID ( INT | ID ) expr) : this( new CommonTreeNodeStream( function.GetChild( 2 ) ), functionDefinitions ) { this.globalMemory = globalMemory; localMemory[function.GetChild( 1 ).Text] = paramValue; }
public void ReduceOnBigIntReducesSmallerValues() { BigInteger b1 = new BigInteger("123"); BigInteger b2 = new BigInteger("0"); BigInteger b3 = new BigInteger(Int32.MaxValue.ToString()); BigInteger b4 = new BigInteger(Int32.MinValue.ToString()); ExpectInt32(Numbers.reduce(b1)); ExpectInt32(Numbers.reduce(b2)); ExpectInt32(Numbers.reduce(b3)); ExpectInt32(Numbers.reduce(b4)); }
public void ReduceOnBigIntReturnsLargerValues() { BigInteger b1 = new BigInteger("100000000000000000000", 16); BigInteger b2 = b1.negate(); BigInteger b3 = new BigInteger("123456789012345678901234567890"); BigInteger b4 = b3.negate(); ExpectSameObject(b1, Numbers.reduce(b1)); ExpectSameObject(b2, Numbers.reduce(b2)); ExpectSameObject(b3, Numbers.reduce(b3)); ExpectSameObject(b4, Numbers.reduce(b4)); }
// https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2015/201511/20151103/rsaparameters // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2014/201408/20140829 public RSAPrivateCrtKeySpec(BigInteger modulus, BigInteger publicExponent, BigInteger privateExponent, BigInteger primeP, BigInteger primeQ, BigInteger primeExponentP, BigInteger primeExponentQ, BigInteger crtCoefficient) : base(modulus, privateExponent) { }
/// <summary>Test the input number to be probability a prime number.</summary> /// <remarks>Test the input number to be probability a prime number.</remarks> /// <param name="number">Number for prime test</param> /// <returns> /// Return true is a probability a prime and false if sure not a /// prime /// </returns> public virtual bool isPrime(BigInteger number) { bool result = false; SecureRandom random = new SecureRandom(); for (int i = 0; i < this.rounds; i++) { result = runMillerRabin(number, random); } if (result == false) { this.probability = 0; } else { this.probability = this.calcProbability(this.rounds); } return result; }
/** Find matching function definition for a function name and parameter * value. The first definition is returned where (a) the name matches * and (b) the formal parameter agrees if it is defined as constant. */ private CommonTree findFunction( string name, BigInteger paramValue ) { foreach ( CommonTree f in functionDefinitions ) { // Expected tree for f: ^(FUNC ID (ID | INT) expr) if ( f.GetChild( 0 ).Text.Equals( name ) ) { // Check whether parameter matches CommonTree formalPar = (CommonTree)f.GetChild( 1 ); if ( formalPar.Token.Type == INT && !new BigInteger( formalPar.Token.Text ).Equals( paramValue ) ) { // Constant in formalPar list does not match actual value -> no match. continue; } // Parameter (value for INT formal arg) as well as fct name agrees! return f; } } return null; }
/** Find matching function definition for a function name and parameter * value. The first definition is returned where (a) the name matches * and (b) the formal parameter agrees if it is defined as constant. */ private CommonTree findFunction(string name, BigInteger paramValue) { foreach (CommonTree f in functionDefinitions) { // Expected tree for f: ^(FUNC ID (ID | INT) expr) if (f.GetChild(0).Text.Equals(name)) { // Check whether parameter matches CommonTree formalPar = (CommonTree)f.GetChild(1); if (formalPar.Token.Type == INT && !new BigInteger(formalPar.Token.Text).Equals(paramValue)) { // Constant in formalPar list does not match actual value -> no match. continue; } // Parameter (value for INT formal arg) as well as fct name agrees! return(f); } } return(null); }
public static object reduce(BigInteger val) { //return (val.bitLength() < 32) ? (object)val.intValue() : val; int bitLength = val.bitLength(); return (bitLength < 32) ? (object)val.intValue() : (bitLength < 64) ? (object)val.longValue() : val; }
public static object BIDivide(BigInteger n, BigInteger d) { if (d.Equals(BigIntegerZero)) throw new ArithmeticException("Divide by zero"); BigInteger gcd = n.gcd(d); if (gcd.Equals(BigIntegerZero)) return 0; n = n.divide(gcd); d = d.divide(gcd); if (d.Equals(BigIntegerOne)) return reduce(n); return new Ratio((d.signum() < 0 ? n.negate() : n), (d.signum() < 0 ? d.negate() : d)); }
/// <summary> /// Returns a BigInteger whose value is <tt>(this - val)</tt>. /// </summary> public BigInteger subtract(BigInteger @val) { return default(BigInteger); }
/// <summary> /// Returns a BigInteger whose value is <tt>(this<sup>-1</sup> mod m)</tt>. /// </summary> public BigInteger modInverse(BigInteger @m) { return default(BigInteger); }
/// <summary> /// Returns the minimum of this BigInteger and <tt>val</tt>. /// </summary> public BigInteger min(BigInteger @val) { return default(BigInteger); }
/// <summary> /// Returns an array of two BigIntegers containing <tt>(this / val)</tt> /// followed by <tt>(this % val)</tt>. /// </summary> public BigInteger[] divideAndRemainder(BigInteger @val) { return default(BigInteger[]); }
public void testBigInt1024() { for(int i = 0; i < cycles; i++) { BigInteger testBigInt = new BigInteger(big1024); } }
public void testBigInt2048() { for(int i = 0; i < cycles; i++) { BigInteger testBigInt = new BigInteger(big2048); } }
public static object matchNumber(string s) { Match m = intRE.Match(s); if ( m.Success ) { if ( m.Groups[2].Success ) // matched 0 only return 0; bool isNeg = m.Groups[1].Value == "-"; string n = null; int radix = 10; if (m.Groups[3].Success) { n = m.Groups[3].Value; radix = 10; } else if (m.Groups[4].Success) { n = m.Groups[4].Value; radix = 16; } else if (m.Groups[5].Success) { n = m.Groups[5].Value; radix = 8; } else if (m.Groups[7].Success) { n = m.Groups[7].Value; radix = Int32.Parse(m.Groups[6].Value); } if (n == null) return null; BigInteger bn = new BigInteger(n, radix); return Numbers.reduce(isNeg ? bn.negate() : bn); } m = floatRE.Match(s); if (m.Success) { return ( s[s.Length-1] == 'M' ) ? new BigDecimal( s.Substring(0,s.Length-1)) // TODO: Fix MS inadequacy : (object)Double.Parse(s); } m = ratioRE.Match(s); if (m.Success) { // There is a bug in the BigInteger c-tor that causes it barf on a leading +. string numerString = m.Groups[1].Value; string denomString = m.Groups[2].Value; if (numerString[0] == '+') numerString = numerString.Substring(1); return Numbers.BIDivide(new BigInteger(numerString), new BigInteger(denomString)); } return null; }
/// <summary> /// Returns a BigInteger whose value is /// <tt>(this<sup>exponent</sup> mod m)</tt>. /// </summary> public BigInteger modPow(BigInteger @exponent, BigInteger @m) { return default(BigInteger); }
/// <summary> /// Returns a BigInteger whose value is <tt>(this * val)</tt>. /// </summary> public BigInteger multiply(BigInteger @val) { return default(BigInteger); }
/// <summary> /// Returns a BigInteger whose value is <tt>(this & ~val)</tt>. /// </summary> public BigInteger andNot(BigInteger @val) { return default(BigInteger); }
/// <summary> /// Returns a BigInteger whose value is <tt>(this ^ val)</tt>. /// </summary> public BigInteger xor(BigInteger @val) { return default(BigInteger); }
private static byte[] encryptBlock(byte[] block, BigInteger n) { BigInteger blockInt = new BigInteger(block); if (blockInt.compareTo(BigInteger.ZERO) < 0) { blockInt = blockInt.modPow(E, n); return blockInt.multiply(BigInteger.valueOf(-1)).toByteArray(); } else { return (blockInt).modPow(E, n).toByteArray(); } }
// $ANTLR end "prog" // $ANTLR start "stat" // BuildOptions\\ProfileTreeGrammar.g3:56:0: stat : ( expr | ^( '=' ID expr ) | ^( FUNC ( . )+ ) ); private void stat( ) { CommonTree ID2 = null; BigInteger expr1 = default(BigInteger); BigInteger expr3 = default(BigInteger); try { dbg.EnterRule(GrammarFileName, "stat"); if (RuleLevel == 0) { dbg.Commence(); } IncRuleLevel(); dbg.Location(56, -1); try { // BuildOptions\\ProfileTreeGrammar.g3:56:9: ( expr | ^( '=' ID expr ) | ^( FUNC ( . )+ ) ) int alt3 = 3; try { dbg.EnterDecision(3); switch (input.LA(1)) { case CALL: case ID: case INT: case 10: case 11: case 14: case 15: case 16: { alt3 = 1; } break; case 17: { alt3 = 2; } break; case FUNC: { alt3 = 3; } break; default: { NoViableAltException nvae = new NoViableAltException("", 3, 0, input); dbg.RecognitionException(nvae); throw nvae; } } } finally { dbg.ExitDecision(3); } switch (alt3) { case 1: dbg.EnterAlt(1); // BuildOptions\\ProfileTreeGrammar.g3:56:9: expr { dbg.Location(56, 8); PushFollow(Follow._expr_in_stat63); expr1 = expr(); state._fsp--; dbg.Location(56, 35); string result = expr1.ToString(); Console.Out.WriteLine(expr1 + " (about " + result[0] + "*10^" + (result.Length - 1) + ")"); } break; case 2: dbg.EnterAlt(2); // BuildOptions\\ProfileTreeGrammar.g3:59:9: ^( '=' ID expr ) { dbg.Location(59, 8); dbg.Location(59, 10); Match(input, 17, Follow._17_in_stat98); Match(input, TokenTypes.Down, null); dbg.Location(59, 14); ID2 = (CommonTree)Match(input, ID, Follow._ID_in_stat100); dbg.Location(59, 17); PushFollow(Follow._expr_in_stat102); expr3 = expr(); state._fsp--; Match(input, TokenTypes.Up, null); dbg.Location(59, 35); globalMemory[(ID2 != null?ID2.Text:null)] = expr3; } break; case 3: dbg.EnterAlt(3); // BuildOptions\\ProfileTreeGrammar.g3:60:9: ^( FUNC ( . )+ ) { dbg.Location(60, 8); dbg.Location(60, 10); Match(input, FUNC, Follow._FUNC_in_stat128); Match(input, TokenTypes.Down, null); dbg.Location(60, 15); // BuildOptions\\ProfileTreeGrammar.g3:60:16: ( . )+ int cnt2 = 0; try { dbg.EnterSubRule(2); for ( ; ;) { int alt2 = 2; try { dbg.EnterDecision(2); int LA2_0 = input.LA(1); if (((LA2_0 >= CALL && LA2_0 <= 17))) { alt2 = 1; } else if ((LA2_0 == UP)) { alt2 = 2; } } finally { dbg.ExitDecision(2); } switch (alt2) { case 1: dbg.EnterAlt(1); // BuildOptions\\ProfileTreeGrammar.g3:60:0: . { dbg.Location(60, 15); MatchAny(input); } break; default: if (cnt2 >= 1) { goto loop2; } EarlyExitException eee2 = new EarlyExitException(2, input); dbg.RecognitionException(eee2); throw eee2; } cnt2++; } loop2: ; } finally { dbg.ExitSubRule(2); } Match(input, TokenTypes.Up, null); } break; } } catch (RecognitionException re) { ReportError(re); Recover(input, re); } finally { } dbg.Location(61, 4); } finally { dbg.ExitRule(GrammarFileName, "stat"); DecRuleLevel(); if (RuleLevel == 0) { dbg.Terminate(); } } return; }
/// <summary> /// Returns a BigInteger whose value is <tt>(this mod m</tt>). /// </summary> public BigInteger mod(BigInteger @m) { return default(BigInteger); }
// $ANTLR end "stat" // $ANTLR start "expr" // BuildOptions\\ProfileTreeGrammar.g3:63:0: expr returns [BigInteger value] : ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ^( '/' a= expr b= expr ) | ^( '%' a= expr b= expr ) | ID | INT | call ); private BigInteger expr( ) { BigInteger value = default(BigInteger); CommonTree ID4 = null; CommonTree INT5 = null; BigInteger a = default(BigInteger); BigInteger b = default(BigInteger); BigInteger call6 = default(BigInteger); try { dbg.EnterRule(GrammarFileName, "expr"); if (RuleLevel == 0) { dbg.Commence(); } IncRuleLevel(); dbg.Location(63, -1); try { // BuildOptions\\ProfileTreeGrammar.g3:64:9: ( ^( '+' a= expr b= expr ) | ^( '-' a= expr b= expr ) | ^( '*' a= expr b= expr ) | ^( '/' a= expr b= expr ) | ^( '%' a= expr b= expr ) | ID | INT | call ) int alt4 = 8; try { dbg.EnterDecision(4); switch (input.LA(1)) { case 16: { alt4 = 1; } break; case 10: { alt4 = 2; } break; case 14: { alt4 = 3; } break; case 15: { alt4 = 4; } break; case 11: { alt4 = 5; } break; case ID: { alt4 = 6; } break; case INT: { alt4 = 7; } break; case CALL: { alt4 = 8; } break; default: { NoViableAltException nvae = new NoViableAltException("", 4, 0, input); dbg.RecognitionException(nvae); throw nvae; } } } finally { dbg.ExitDecision(4); } switch (alt4) { case 1: dbg.EnterAlt(1); // BuildOptions\\ProfileTreeGrammar.g3:64:9: ^( '+' a= expr b= expr ) { dbg.Location(64, 8); dbg.Location(64, 10); Match(input, 16, Follow._16_in_expr172); Match(input, TokenTypes.Down, null); dbg.Location(64, 15); PushFollow(Follow._expr_in_expr176); a = expr(); state._fsp--; dbg.Location(64, 22); PushFollow(Follow._expr_in_expr180); b = expr(); state._fsp--; Match(input, TokenTypes.Up, null); dbg.Location(64, 35); value = a.add(b); } break; case 2: dbg.EnterAlt(2); // BuildOptions\\ProfileTreeGrammar.g3:65:9: ^( '-' a= expr b= expr ) { dbg.Location(65, 8); dbg.Location(65, 10); Match(input, 10, Follow._10_in_expr200); Match(input, TokenTypes.Down, null); dbg.Location(65, 15); PushFollow(Follow._expr_in_expr204); a = expr(); state._fsp--; dbg.Location(65, 22); PushFollow(Follow._expr_in_expr208); b = expr(); state._fsp--; Match(input, TokenTypes.Up, null); dbg.Location(65, 35); value = a.subtract(b); } break; case 3: dbg.EnterAlt(3); // BuildOptions\\ProfileTreeGrammar.g3:66:9: ^( '*' a= expr b= expr ) { dbg.Location(66, 8); dbg.Location(66, 10); Match(input, 14, Follow._14_in_expr228); Match(input, TokenTypes.Down, null); dbg.Location(66, 15); PushFollow(Follow._expr_in_expr232); a = expr(); state._fsp--; dbg.Location(66, 22); PushFollow(Follow._expr_in_expr236); b = expr(); state._fsp--; Match(input, TokenTypes.Up, null); dbg.Location(66, 35); value = a.multiply(b); } break; case 4: dbg.EnterAlt(4); // BuildOptions\\ProfileTreeGrammar.g3:67:9: ^( '/' a= expr b= expr ) { dbg.Location(67, 8); dbg.Location(67, 10); Match(input, 15, Follow._15_in_expr256); Match(input, TokenTypes.Down, null); dbg.Location(67, 15); PushFollow(Follow._expr_in_expr260); a = expr(); state._fsp--; dbg.Location(67, 22); PushFollow(Follow._expr_in_expr264); b = expr(); state._fsp--; Match(input, TokenTypes.Up, null); dbg.Location(67, 35); value = a.divide(b); } break; case 5: dbg.EnterAlt(5); // BuildOptions\\ProfileTreeGrammar.g3:68:9: ^( '%' a= expr b= expr ) { dbg.Location(68, 8); dbg.Location(68, 10); Match(input, 11, Follow._11_in_expr284); Match(input, TokenTypes.Down, null); dbg.Location(68, 15); PushFollow(Follow._expr_in_expr288); a = expr(); state._fsp--; dbg.Location(68, 22); PushFollow(Follow._expr_in_expr292); b = expr(); state._fsp--; Match(input, TokenTypes.Up, null); dbg.Location(68, 35); value = a.remainder(b); } break; case 6: dbg.EnterAlt(6); // BuildOptions\\ProfileTreeGrammar.g3:69:9: ID { dbg.Location(69, 8); ID4 = (CommonTree)Match(input, ID, Follow._ID_in_expr311); dbg.Location(69, 35); value = getValue((ID4 != null?ID4.Text:null)); } break; case 7: dbg.EnterAlt(7); // BuildOptions\\ProfileTreeGrammar.g3:70:9: INT { dbg.Location(70, 8); INT5 = (CommonTree)Match(input, INT, Follow._INT_in_expr347); dbg.Location(70, 35); value = new BigInteger((INT5 != null?INT5.Text:null)); } break; case 8: dbg.EnterAlt(8); // BuildOptions\\ProfileTreeGrammar.g3:71:9: call { dbg.Location(71, 8); PushFollow(Follow._call_in_expr382); call6 = call(); state._fsp--; dbg.Location(71, 35); value = call6; } break; } } catch (RecognitionException re) { ReportError(re); Recover(input, re); } finally { } dbg.Location(72, 4); } finally { dbg.ExitRule(GrammarFileName, "expr"); DecRuleLevel(); if (RuleLevel == 0) { dbg.Terminate(); } } return(value); }
/// <summary> /// Returns a BigInteger whose value is the greatest common divisor of /// <tt>abs(this)</tt> and <tt>abs(val)</tt>. /// </summary> public BigInteger gcd(BigInteger @val) { return default(BigInteger); }
// $ANTLR end "expr" // $ANTLR start "call" // BuildOptions\\ProfileTreeGrammar.g3:74:0: call returns [BigInteger value] : ^( CALL ID expr ) ; private BigInteger call( ) { BigInteger value = default(BigInteger); CommonTree ID8 = null; BigInteger expr7 = default(BigInteger); try { dbg.EnterRule(GrammarFileName, "call"); if (RuleLevel == 0) { dbg.Commence(); } IncRuleLevel(); dbg.Location(74, -1); try { // BuildOptions\\ProfileTreeGrammar.g3:75:9: ( ^( CALL ID expr ) ) dbg.EnterAlt(1); // BuildOptions\\ProfileTreeGrammar.g3:75:9: ^( CALL ID expr ) { dbg.Location(75, 8); dbg.Location(75, 10); Match(input, CALL, Follow._CALL_in_call430); Match(input, TokenTypes.Down, null); dbg.Location(75, 15); ID8 = (CommonTree)Match(input, ID, Follow._ID_in_call432); dbg.Location(75, 18); PushFollow(Follow._expr_in_call434); expr7 = expr(); state._fsp--; Match(input, TokenTypes.Up, null); dbg.Location(75, 35); BigInteger p = expr7; CommonTree funcRoot = findFunction((ID8 != null?ID8.Text:null), p); if (funcRoot == null) { Console.Error.WriteLine("No match found for " + (ID8 != null?ID8.Text:null) + "(" + p + ")"); } else { // Here we set up the local evaluator to run over the // function definition with the parameter value. // This re-reads a sub-AST of our input AST! ProfileTreeGrammar e = new ProfileTreeGrammar(funcRoot, functionDefinitions, globalMemory, p); value = e.expr(); } } } catch (RecognitionException re) { ReportError(re); Recover(input, re); } finally { } dbg.Location(87, 4); } finally { dbg.ExitRule(GrammarFileName, "call"); DecRuleLevel(); if (RuleLevel == 0) { dbg.Terminate(); } } return(value); }
public void testBigInt512() { for(int i = 0; i < cycles; i++) { BigInteger testBigInt = new BigInteger(big512); } }
/// <summary> /// Returns a BigInteger whose value is <tt>(this % val)</tt>. /// </summary> public BigInteger remainder(BigInteger @val) { return default(BigInteger); }